diff --git a/incubator/declarative-linking/pom.xml b/incubator/declarative-linking/pom.xml
new file mode 100644
index 0000000..592cb2a
--- /dev/null
+++ b/incubator/declarative-linking/pom.xml
@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+
+    This program and the accompanying materials are made available under the
+    terms of the Eclipse Public License v. 2.0, which is available at
+    http://www.eclipse.org/legal/epl-2.0.
+
+    This Source Code may also be made available under the following Secondary
+    Licenses when the conditions for such availability set forth in the
+    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+    version 2 with the GNU Classpath Exception, which is available at
+    https://www.gnu.org/software/classpath/license.html.
+
+    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.glassfish.jersey.incubator</groupId>
+        <artifactId>project</artifactId>
+        <version>2.28-SNAPSHOT</version>
+    </parent>
+
+    <groupId>org.glassfish.jersey.ext</groupId>
+    <artifactId>jersey-declarative-linking</artifactId>
+    <packaging>jar</packaging>
+
+    <name>jersey-declarative-linking</name>
+
+    <description>
+        Jersey support for declarative hyperlinking.
+    </description>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-common</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-server</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>javax.el</groupId>
+            <artifactId>javax.el-api</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.web</groupId>
+            <artifactId>javax.el</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.glassfish.jersey.test-framework.providers</groupId>
+            <artifactId>jersey-test-framework-provider-grizzly2</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.media</groupId>
+            <artifactId>jersey-media-json-jackson</artifactId>
+            <version>${jersey.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.skyscreamer</groupId>
+            <artifactId>jsonassert</artifactId>
+            <version>1.4.0</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <profiles>
+        <profile>
+            <id>release</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-javadoc-plugin</artifactId>
+                        <configuration>
+                            <links>
+                                <link>https://jsr311.java.net/nonav/releases/1.1</link>
+                                <link>https://jersey.java.net/nonav/apidocs/latest/jersey/</link>
+                            </links>
+                            <notimestamp>true</notimestamp>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+        <profile>
+            <id>cobertura</id>
+            <activation>
+                <property>
+                    <name>cobertura</name>
+                </property>
+            </activation>
+            <dependencies>
+                <dependency>
+                    <groupId>org.glassfish.jersey.core</groupId>
+                    <artifactId>jersey-common</artifactId>
+                    <version>${project.version}</version>
+                    <classifier>cobertura</classifier>
+                </dependency>
+            </dependencies>
+        </profile>
+        <profile>
+            <id>default</id>
+            <activation>
+                <activeByDefault>true</activeByDefault>
+            </activation>
+            <dependencies>
+                <dependency>
+                    <groupId>org.glassfish.jersey.core</groupId>
+                    <artifactId>jersey-common</artifactId>
+                    <version>${project.version}</version>
+                </dependency>
+            </dependencies>
+        </profile>
+    </profiles>
+
+    <build>
+        <resources>
+            <resource>
+                <directory>${basedir}/src/main/java</directory>
+                <includes>
+                    <include>META-INF/**/*</include>
+                </includes>
+            </resource>
+        </resources>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>attach-sources</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/Binding.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/Binding.java
new file mode 100644
index 0000000..94b5bf2
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/Binding.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.glassfish.jersey.Beta;
+
+/**
+ * Specifies the binding between a URI template parameter and a bean property.
+ * @see org.glassfish.jersey.linking.InjectLink#bindings()
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+@Target({})
+@Retention(RetentionPolicy.RUNTIME)
+@Beta
+public @interface Binding {
+
+    /**
+     * Specifies the name of the URI template parameter, defaults to
+     * "value" for convenience.
+     */
+    String name() default "value";
+
+    /**
+     * Specifies the value of a URI template parameter. The value is an EL
+     * expression using immediate evaluation syntax. E.g.:
+     * <pre>${instance.widgetId}</pre>
+     * In the above example the value is taken from the <code>widgetId</code>
+     * property of the implicit <code>instance</code> bean.
+     * <p>Three implicit beans are supported:</p>
+     * <dl>
+     * <dt><code>instance</code></dt><dd>The object whose class contains the
+     * {@link org.glassfish.jersey.linking.InjectLink} annotation.</dd>
+     * <dt><code>entity</code></dt><dd>The entity returned by the resource
+     * class method. This is either the resource method return value
+     * or the entity property for a resource method that returns Response.</dd>
+     * <dt><code>resource</code></dt><dd>The resource class instance that
+     * returned the object that contains the {@code InjectLink} annotation.</dd>
+     * </dd>
+     * </dl>
+     */
+    String value();
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/DeclarativeLinkingFeature.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/DeclarativeLinkingFeature.java
new file mode 100644
index 0000000..a215464
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/DeclarativeLinkingFeature.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import javax.ws.rs.core.Configuration;
+import javax.ws.rs.core.Feature;
+import javax.ws.rs.core.FeatureContext;
+
+import javax.inject.Singleton;
+
+import org.glassfish.jersey.Beta;
+import org.glassfish.jersey.internal.inject.AbstractBinder;
+import org.glassfish.jersey.linking.contributing.NaiveResourceLinkContributionContext;
+import org.glassfish.jersey.linking.contributing.ResourceLinkContributionContext;
+import org.glassfish.jersey.linking.mapping.NaiveResourceMappingContext;
+import org.glassfish.jersey.linking.mapping.ResourceMappingContext;
+
+/**
+ * A feature to enable the declarative linking functionality.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+@Beta
+public class DeclarativeLinkingFeature implements Feature {
+
+    @Override
+    public boolean configure(FeatureContext context) {
+
+        Configuration config = context.getConfiguration();
+        if (!config.isRegistered(ResponseLinkFilter.class)) {
+            context.register(new AbstractBinder() {
+
+                @Override
+                protected void configure() {
+                    bindAsContract(NaiveResourceMappingContext.class)
+                            .to(ResourceMappingContext.class).in(Singleton.class);
+                }
+            });
+            context.register(new AbstractBinder() {
+
+                @Override
+                protected void configure() {
+                    bindAsContract(NaiveResourceLinkContributionContext.class)
+                            .to(ResourceLinkContributionContext.class).in(Singleton.class);
+                }
+            });
+
+            context.register(ResponseLinkFilter.class);
+
+            // TODO: map values back?
+            // context.register(RequestLinkFilter.class);
+            return true;
+        }
+        return false;
+    }
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ELLinkBuilder.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ELLinkBuilder.java
new file mode 100644
index 0000000..8e777be
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ELLinkBuilder.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.net.URI;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.ws.rs.core.UriBuilder;
+import javax.ws.rs.core.UriInfo;
+
+import javax.el.ExpressionFactory;
+import javax.el.ValueExpression;
+
+import org.glassfish.jersey.linking.mapping.ResourceMappingContext;
+import org.glassfish.jersey.uri.internal.UriTemplateParser;
+
+/**
+ * A helper class to build links from EL expressions.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+final class ELLinkBuilder {
+
+    private ELLinkBuilder() {
+    }
+
+    private static final ExpressionFactory expressionFactory =
+            ExpressionFactory.newInstance();
+
+    /**
+     * Evaluates the condition
+     *
+     * @param condition the condition expression
+     * @param entity    the entity returned from the resource method
+     * @param resource  the resource class instance that returned the entity
+     * @param instance  the instance that contains the entity, e.g. the value of a field within an entity class.
+     * @return the result of the condition
+     */
+    static boolean evaluateCondition(String condition,
+                                     Object entity,
+                                     Object resource,
+                                     Object instance) {
+
+        if (condition == null || condition.isEmpty()) {
+            return true;
+        }
+        LinkELContext context = new LinkELContext(entity, resource, instance);
+        ValueExpression expr = expressionFactory.createValueExpression(context, condition, boolean.class);
+
+        Object result = expr.getValue(context).toString();
+        return "true".equals(result);
+    }
+
+    /**
+     * Creates the URI using the link descriptor.
+     *
+     * @param link the link descriptor
+     * @param entity the entity returned from the resource method
+     * @param resource the resource class instance that returned the entity
+     * @param instance the instance that contains the entity, e.g. the value of a field within an entity class.
+     * @param uriInfo JAX-RS {@link UriInfo}
+     * @param rmc the {@link ResourceMappingContext}
+     * @return the URI
+     */
+    static URI buildURI(InjectLinkDescriptor link,
+                        Object entity,
+                        Object resource,
+                        Object instance,
+                        UriInfo uriInfo,
+                        ResourceMappingContext rmc) {
+
+        String template = link.getLinkTemplate(rmc);
+
+        // first process any embedded EL expressions
+        LinkELContext context = new LinkELContext(entity, resource, instance);
+        ValueExpression expr = expressionFactory.createValueExpression(context,
+                template, String.class);
+        template = expr.getValue(context).toString();
+
+        // now process any embedded URI template parameters
+        UriBuilder ub = applyLinkStyle(template, link.getLinkStyle(), uriInfo);
+        UriTemplateParser parser = new UriTemplateParser(template);
+        List<String> parameterNames = parser.getNames();
+        Map<String, Object> valueMap = getParameterValues(parameterNames, link, context, uriInfo);
+        return ub.buildFromMap(valueMap);
+    }
+
+    private static UriBuilder applyLinkStyle(String template, InjectLink.Style style, UriInfo uriInfo) {
+        UriBuilder ub = null;
+        switch (style) {
+            case ABSOLUTE:
+                ub = uriInfo.getBaseUriBuilder().path(template);
+                break;
+            case ABSOLUTE_PATH:
+                String basePath = uriInfo.getBaseUri().getPath();
+                ub = UriBuilder.fromPath(basePath).path(template);
+                break;
+            case RELATIVE_PATH:
+                ub = UriBuilder.fromPath(template);
+                break;
+        }
+        return ub;
+    }
+
+    private static Map<String, Object> getParameterValues(List<String> parameterNames,
+                                                          InjectLinkDescriptor linkField,
+                                                          LinkELContext context,
+                                                          UriInfo uriInfo) {
+        Map<String, Object> values = new HashMap<>();
+        for (String name : parameterNames) {
+            String elExpression = linkField.getBinding(name);
+            if (elExpression == null) {
+                String value = uriInfo.getPathParameters().getFirst(name);
+                if (value == null) {
+                    value = uriInfo.getQueryParameters().getFirst(name);
+                }
+                if (value != null) {
+                    values.put(name, value);
+                    continue;
+                }
+                elExpression = "${" + ResponseContextResolver.INSTANCE_OBJECT + "." + name + "}";
+            }
+            ValueExpression expr = expressionFactory.createValueExpression(context,
+                        elExpression, String.class);
+
+            Object value = expr.getValue(context);
+            values.put(name, value != null ? value.toString() : null);
+         }
+        return values;
+    }
+
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/EntityDescriptor.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/EntityDescriptor.java
new file mode 100644
index 0000000..314c839
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/EntityDescriptor.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.ws.rs.core.Link;
+
+/**
+ * Describes an entity in terms of its fields, bean properties and {@link InjectLink}
+ * annotated fields.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+class EntityDescriptor {
+
+    // Maintains an internal static cache to optimize processing
+    private static final Map<Class<?>, EntityDescriptor> descriptors = new HashMap<>();
+
+    static synchronized EntityDescriptor getInstance(Class<?> entityClass) {
+        if (descriptors.containsKey(entityClass)) {
+            return descriptors.get(entityClass);
+        } else {
+            EntityDescriptor descriptor = new EntityDescriptor(entityClass);
+            descriptors.put(entityClass, descriptor);
+            return descriptor;
+        }
+    }
+
+    // instance
+
+    private Map<String, FieldDescriptor> nonLinkFields;
+    private Map<String, FieldDescriptor> linkFields;
+    private List<LinkHeaderDescriptor> linkHeaders;
+
+    /**
+     * Construct an new descriptor by inspecting the supplied class.
+     *
+     * @param entityClass
+     */
+    private EntityDescriptor(Class<?> entityClass) {
+        // create a list of link headers
+        this.linkHeaders = new ArrayList<>();
+        findLinkHeaders(entityClass);
+        this.linkHeaders = Collections.unmodifiableList(linkHeaders);
+
+        // create a list of field names
+        this.nonLinkFields = new HashMap<>();
+        this.linkFields = new HashMap<>();
+        findFields(entityClass);
+        this.nonLinkFields = Collections.unmodifiableMap(this.nonLinkFields);
+        this.linkFields = Collections.unmodifiableMap(this.linkFields);
+    }
+
+    Collection<FieldDescriptor> getLinkFields() {
+        return linkFields.values();
+    }
+
+    Collection<FieldDescriptor> getNonLinkFields() {
+        return nonLinkFields.values();
+    }
+
+    List<LinkHeaderDescriptor> getLinkHeaders() {
+        return linkHeaders;
+    }
+
+    /**
+     * Find and cache the fields of the supplied class and its superclasses and
+     * interfaces.
+     *
+     * @param entityClass the class
+     */
+    private void findFields(Class<?> entityClass) {
+        for (Field f : entityClass.getDeclaredFields()) {
+            InjectLink a = f.getAnnotation(InjectLink.class);
+            Class<?> t = f.getType();
+            if (a != null) {
+                if (t.equals(String.class) || t.equals(URI.class) || Link.class.isAssignableFrom(t)) {
+                    if (!linkFields.containsKey(f.getName())) {
+                        linkFields.put(f.getName(), new InjectLinkFieldDescriptor(f, a, t));
+                    }
+                } else {
+                    // TODO unsupported type
+                }
+            } else if (f.isAnnotationPresent(InjectLinks.class)) {
+
+                if (List.class.isAssignableFrom(t)
+                        || t.isArray() && Link.class.isAssignableFrom(t.getComponentType())) {
+
+                    InjectLinks a2 = f.getAnnotation(InjectLinks.class);
+                    linkFields.put(f.getName(), new InjectLinksFieldDescriptor(f, a2, t));
+                } else {
+                    throw new IllegalArgumentException("Can only inject links onto a List<Link> or Link[] object");
+                }
+
+            } else {
+                // see issue http://java.net/jira/browse/JERSEY-625
+                if ((f.getModifiers() & Modifier.STATIC) > 0
+                        || f.getName().startsWith("java.")
+                        || f.getName().startsWith("javax.")) {
+                    continue;
+                }
+                nonLinkFields.put(f.getName(), new FieldDescriptor(f));
+            }
+        }
+
+        // look for nonLinkFields in superclasses
+        Class<?> sc = entityClass.getSuperclass();
+        if (sc != null && sc != Object.class) {
+            findFields(sc);
+        }
+
+        // look for nonLinkFields in interfaces
+        for (Class<?> ic : entityClass.getInterfaces()) {
+            findFields(ic);
+        }
+    }
+
+    private void findLinkHeaders(Class<?> entityClass) {
+        InjectLink linkHeaderAnnotation = entityClass.getAnnotation(InjectLink.class);
+        if (linkHeaderAnnotation != null) {
+            linkHeaders.add(new LinkHeaderDescriptor(linkHeaderAnnotation));
+        }
+        InjectLinks linkHeadersAnnotation = entityClass.getAnnotation(InjectLinks.class);
+        if (linkHeadersAnnotation != null) {
+            for (InjectLink linkHeader : linkHeadersAnnotation.value()) {
+                linkHeaders.add(new LinkHeaderDescriptor(linkHeader));
+            }
+        }
+
+        // look in superclasses
+        Class<?> sc = entityClass.getSuperclass();
+        if (sc != null && sc != Object.class) {
+            findLinkHeaders(sc);
+        }
+
+        // look in interfaces
+        for (Class<?> ic : entityClass.getInterfaces()) {
+            findLinkHeaders(ic);
+        }
+    }
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/FieldDescriptor.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/FieldDescriptor.java
new file mode 100644
index 0000000..da44b68
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/FieldDescriptor.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Utility class for working with class fields
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+class FieldDescriptor {
+
+    protected Field field;
+
+    FieldDescriptor(Field f) {
+        this.field = f;
+    }
+
+    Object getFieldValue(Object instance) {
+        setAccessibleField(field);
+        Object value = null;
+        try {
+            value = field.get(instance);
+        } catch (IllegalArgumentException | IllegalAccessException ex) {
+            Logger.getLogger(FieldDescriptor.class.getName()).log(Level.FINE, null, ex);
+        }
+        return value;
+    }
+
+    public String getFieldName() {
+        return field.getName();
+    }
+
+    static void setAccessibleField(final Field f) {
+        if (Modifier.isPublic(f.getModifiers())) {
+            return;
+        }
+
+        AccessController.doPrivileged(new PrivilegedAction<Object>() {
+            public Object run() {
+                if (!f.isAccessible()) {
+                    f.setAccessible(true);
+                }
+                return f;
+            }
+        });
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final FieldDescriptor other = (FieldDescriptor) obj;
+        if (this.field != other.field && (this.field == null || !this.field.equals(other.field))) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 7;
+        hash = 83 * hash + (this.field != null ? this.field.hashCode() : 0);
+        return hash;
+    }
+
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/FieldProcessor.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/FieldProcessor.java
new file mode 100644
index 0000000..db852dd
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/FieldProcessor.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.lang.reflect.Modifier;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.core.Link;
+import javax.ws.rs.core.UriInfo;
+
+import javax.xml.bind.annotation.XmlTransient;
+
+import org.glassfish.jersey.linking.contributing.ResourceLinkContributionContext;
+import org.glassfish.jersey.linking.mapping.ResourceMappingContext;
+
+/**
+ * Utility class that can inject links into {@link org.glassfish.jersey.linking.InjectLink} annotated fields in
+ * an entity.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+class FieldProcessor<T> {
+
+    private EntityDescriptor instanceDescriptor;
+    private static final Logger log = Logger.getLogger(FieldProcessor.class.getName());
+
+    FieldProcessor(Class<T> c) {
+        instanceDescriptor = EntityDescriptor.getInstance(c);
+    }
+
+    /**
+     * Inject any {@link org.glassfish.jersey.linking.InjectLink} annotated fields in the supplied entity and
+     * recursively process its fields.
+     *
+     * @param entity  the entity object returned by the resource method
+     * @param uriInfo the uriInfo for the request
+     * @param rmc     the ResourceMappingContext used for building URIs
+     * @param rlcc    the ResourceLinkContributionContext used to find link contributors
+     */
+    void processLinks(T entity, UriInfo uriInfo, ResourceMappingContext rmc, ResourceLinkContributionContext rlcc) {
+        Set<Object> processed = new HashSet<Object>();
+        Object resource = uriInfo.getMatchedResources().get(0);
+        processLinks(entity, resource, entity, processed, uriInfo, rmc, rlcc);
+    }
+
+    /**
+     * Inject any {@link org.glassfish.jersey.linking.InjectLink} annotated fields in the supplied instance. Called
+     * once for the entity and then recursively for each member and field.
+     *
+     * @param entity    the entity object returned by the resource method
+     * @param processed a list of already processed objects, used to break
+     *                  recursion when processing circular references.
+     * @param uriInfo   the uriInfo for the request
+     * @param rmc       the ResourceMappingContext used for building URIs
+     * @param rlcc      the ResourceLinkContributionContext used to find link contributors
+     */
+    private void processLinks(Object entity, Object resource, Object instance,
+            Set<Object> processed, UriInfo uriInfo,
+            ResourceMappingContext rmc, ResourceLinkContributionContext rlcc) {
+
+        try {
+            if (instance == null || processed.contains(instance)) {
+                return; // ignore null properties and defeat circular references
+            }
+            if (instance.getClass().getName().startsWith("java.lang")) {
+                return;
+            }
+            processed.add(instance);
+        } catch (RuntimeException e) {
+            // fix for JERSEY-1656
+            log.log(Level.INFO, LinkMessages.WARNING_LINKFILTER_PROCESSING(instance.getClass().getName()), e);
+        }
+
+        // Process any @Link annotated fields in entity
+        for (FieldDescriptor field : instanceDescriptor.getLinkFields()) {
+
+            // TODO replace with properly poly-morphic code
+            if (field instanceof InjectLinkFieldDescriptor) {
+                InjectLinkFieldDescriptor linkField = (InjectLinkFieldDescriptor) field;
+                if (ELLinkBuilder.evaluateCondition(linkField.getCondition(), entity, resource, instance)) {
+                    URI uri = ELLinkBuilder.buildURI(linkField, entity, resource, instance, uriInfo, rmc);
+                    linkField.setPropertyValue(instance, uri);
+                }
+            } else if (field instanceof InjectLinksFieldDescriptor) {
+
+                InjectLinksFieldDescriptor linksField = (InjectLinksFieldDescriptor) field;
+                List<Link> list = new ArrayList<>();
+                for (InjectLinkFieldDescriptor linkField : linksField.getLinksToInject()) {
+                    if (ELLinkBuilder.evaluateCondition(linkField.getCondition(), entity, resource, instance)) {
+                       URI uri = ELLinkBuilder.buildURI(linkField, entity, resource, instance, uriInfo, rmc);
+                       Link link = linkField.getLink(uri);
+                       list.add(link);
+                    }
+                }
+                List<ProvideLinkDescriptor> linkContributors = rlcc.getContributorsFor(instance.getClass());
+                for (ProvideLinkDescriptor linkContributor : linkContributors) {
+                    if (ELLinkBuilder.evaluateCondition(linkContributor.getCondition(),
+                            entity, linkContributor.getResource(), instance)) {
+                        URI uri = ELLinkBuilder.buildURI(linkContributor, entity, resource, instance, uriInfo, rmc);
+                        Link link = linkContributor.getLink(uri);
+                        list.add(link);
+                    }
+                }
+
+                linksField.setPropertyValue(instance, list);
+            }
+        }
+
+        // If entity is an array, collection, or map then process members
+        Class<?> instanceClass = instance.getClass();
+        if (instanceClass.isArray() && Object[].class.isAssignableFrom(instanceClass)) {
+            Object array[] = (Object[]) instance;
+            for (Object member : array) {
+                processMember(entity, resource, member, processed, uriInfo, rmc, rlcc);
+            }
+        } else if (instance instanceof Iterable) {
+            Iterable iterable = (Iterable) instance;
+            for (Object member : iterable) {
+                processMember(entity, resource, member, processed, uriInfo, rmc, rlcc);
+            }
+        } else if (instance instanceof Map) {
+            Map map = (Map) instance;
+            for (Object member : map.entrySet()) {
+                processMember(entity, resource, member, processed, uriInfo, rmc, rlcc);
+            }
+        }
+
+        // Recursively process all member fields
+        for (FieldDescriptor member : instanceDescriptor.getNonLinkFields()) {
+
+            if (fieldSuitableForIntrospection(member)) {
+                processMember(entity, resource, member.getFieldValue(instance), processed, uriInfo, rmc, rlcc);
+            }
+        }
+
+    }
+
+    private boolean fieldSuitableForIntrospection(FieldDescriptor member) {
+        return member.field == null
+                || (!member.field.isSynthetic()
+                    && !Modifier.isTransient(member.field.getModifiers())
+                    && !member.field.getType().isPrimitive()
+                    && member.field.getType() != String.class
+                    && !member.field.isAnnotationPresent(InjectLinkNoFollow.class)
+                    && !member.field.isAnnotationPresent(XmlTransient.class));
+    }
+
+    private void processMember(Object entity, Object resource, Object member, Set<Object> processed, UriInfo uriInfo,
+            ResourceMappingContext rmc, ResourceLinkContributionContext rlcc) {
+        if (member != null) {
+            FieldProcessor<?> proc = new FieldProcessor(member.getClass());
+            proc.processLinks(entity, resource, member, processed, uriInfo, rmc, rlcc);
+        }
+    }
+
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/HeaderProcessor.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/HeaderProcessor.java
new file mode 100644
index 0000000..770fada
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/HeaderProcessor.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.UriInfo;
+
+import org.glassfish.jersey.linking.mapping.ResourceMappingContext;
+
+/**
+ * Processes @Link and @LinkHeaders annotations on entity classes and
+ * adds appropriate HTTP Link headers.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+class HeaderProcessor<T> {
+
+    private EntityDescriptor instanceDescriptor;
+
+    HeaderProcessor(Class<T> c) {
+        instanceDescriptor = EntityDescriptor.getInstance(c);
+    }
+
+    /**
+     * Process any {@link InjectLink} annotations on the supplied entity.
+     * @param entity the entity object returned by the resource method
+     * @param uriInfo the uriInfo for the request
+     * @param headers the map into which the headers will be added
+     */
+    void processLinkHeaders(T entity,
+                            UriInfo uriInfo,
+                            ResourceMappingContext rmc,
+                            MultivaluedMap<String, Object> headers) {
+        List<String> headerValues = getLinkHeaderValues(entity, uriInfo, rmc);
+        for (String headerValue : headerValues) {
+            headers.add("Link", headerValue);
+        }
+    }
+
+    List<String> getLinkHeaderValues(Object entity, UriInfo uriInfo, ResourceMappingContext rmc) {
+        final List<Object> matchedResources = uriInfo.getMatchedResources();
+
+        if (!matchedResources.isEmpty()) {
+            final Object resource = matchedResources.get(0);
+            final List<String> headerValues = new ArrayList<>();
+
+            for (LinkHeaderDescriptor desc : instanceDescriptor.getLinkHeaders()) {
+                if (ELLinkBuilder.evaluateCondition(desc.getCondition(), entity, resource, entity)) {
+                    String headerValue = getLinkHeaderValue(desc, entity, resource, uriInfo, rmc);
+                    headerValues.add(headerValue);
+                }
+            }
+            return headerValues;
+        }
+
+        return Collections.emptyList();
+    }
+
+    private static String getLinkHeaderValue(LinkHeaderDescriptor desc, Object entity, Object resource, UriInfo uriInfo,
+                                             ResourceMappingContext rmc) {
+        URI uri = ELLinkBuilder.buildURI(desc, entity, resource, entity, uriInfo, rmc);
+        InjectLink link = desc.getLinkHeader();
+        return InjectLink.Util.buildLinkFromUri(uri, link).toString();
+    }
+
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLink.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLink.java
new file mode 100644
index 0000000..a42b3e9
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLink.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.net.URI;
+
+import javax.ws.rs.core.Link;
+
+import org.glassfish.jersey.Beta;
+
+/**
+ * Specifies a link injection target in a returned representation bean. May be
+ * used on fields of type String or URI. One of {@link #value()} or
+ * {@link #resource()} must be specified.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+@Target({ElementType.FIELD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Beta
+public @interface InjectLink {
+
+    /**
+     * Styles of URI supported
+     */
+    enum Style {
+
+        /**
+         * An absolute URI. The URI template will be prefixed with the absolute
+         * base URI of the application.
+         */
+        ABSOLUTE,
+        /**
+         * An absolute path. The URI template will be prefixed with the absolute
+         * base path of the application.
+         */
+        ABSOLUTE_PATH,
+        /**
+         * A relative path. The URI template will be converted to a relative
+         * path with no prefix.
+         */
+        RELATIVE_PATH
+
+    }
+
+    /**
+     * The style of URI to inject
+     */
+    Style style() default Style.ABSOLUTE_PATH;
+
+    /**
+     * Specifies a URI template that will be used to build the injected URI. The
+     * template may contain both URI template parameters (e.g. {id}) and EL
+     * expressions (e.g. ${instance.id}) using the same implicit beans as
+     * {@link Binding#value()}. URI template parameter values are resolved as
+     * described in {@link #resource()}. E.g. the following three alternatives
+     * are equivalent:
+     * <pre>
+     * &#64;Ref("{id}")
+     * &#64;Ref(value="{id}", bindings={
+     *   &#64;Binding(name="id" value="${instance.id}"}
+     * )
+     * &#64;Ref("${instance.id}")
+     * </pre>
+     */
+    String value() default "";
+
+    /**
+     * Specifies a resource class whose @Path URI template will be used to build
+     * the injected URI. Embedded URI template parameter values are resolved as
+     * follows:
+     * <ol>
+     * <li>If the {@link #bindings()} property contains a binding specification
+     * for the parameter then that is used</li>
+     * <li>Otherwise an implicit binding is used that extracts the value of a
+     * bean property by the same name as the URI template from the implicit
+     * {@code instance} bean (see {@link Binding}).</li>
+     * </ol>
+     * <p>
+     * E.g. assuming a resource class {@code SomeResource} with the
+     * following {@code @Path("{id}")} annotation, the following two
+     * alternatives are therefore equivalent:</p>
+     * <pre>
+     * &#64;Ref(resource=SomeResource.class)
+     * &#64;Ref(resource=SomeResource.class, bindings={
+     *   &#64;Binding(name="id" value="${instance.id}"}
+     * )
+     * </pre>
+     */
+    Class<?> resource() default Class.class;
+
+    /**
+     * Used in conjunction with {@link #resource()} to specify a subresource
+     * locator or method. The value is the name of the method. The value of the
+     * method's @Path annotation will be appended to the value of the
+     * class-level @Path annotation separated by '/' if necessary.
+     */
+    String method() default "";
+
+    /**
+     * Specifies the bindings for embedded URI template parameters.
+     *
+     * @see Binding
+     */
+    Binding[] bindings() default {};
+
+    /**
+     * Specifies a boolean EL expression whose value determines whether a Ref is
+     * set (true) or not (false). Omission of a condition will always insert a
+     * ref.
+     */
+    String condition() default "";
+
+    // Link properties
+    //
+
+    /**
+     * Specifies the relationship.
+     */
+    String rel() default "";
+
+    /**
+     * Specifies the reverse relationship.
+     */
+    String rev() default "";
+
+    /**
+     * Specifies the media type.
+     */
+    String type() default "";
+
+    /**
+     * Specifies the title.
+     */
+    String title() default "";
+
+    /**
+     * Specifies the anchor
+     */
+    String anchor() default "";
+
+    /**
+     * Specifies the media
+     */
+    String media() default "";
+
+    /**
+     * Specifies the lang of the referenced resource
+     */
+    String hreflang() default "";
+
+    /**
+     * Specifies extension parameters as name-value pairs.
+     */
+    Extension[] extensions() default {};
+
+    @Target({ElementType.TYPE, ElementType.FIELD})
+    @Retention(RetentionPolicy.RUNTIME)
+    @interface Extension {
+
+        /**
+         * Specifies the name of the extension parameter
+         */
+        String name();
+
+        /**
+         * Specifies the value of the extension parameter
+         */
+        String value();
+    }
+
+    class Util {
+
+        public static Link buildLinkFromUri(URI uri, InjectLink link) {
+
+            javax.ws.rs.core.Link.Builder builder = javax.ws.rs.core.Link.fromUri(uri);
+            if (!link.rel().isEmpty()) {
+                builder = builder.rel(link.rel());
+            }
+            if (!link.rev().isEmpty()) {
+                builder = builder.param("rev", link.rev());
+            }
+            if (!link.type().isEmpty()) {
+                builder = builder.type(link.type());
+            }
+            if (!link.title().isEmpty()) {
+                builder = builder.param("title", link.title());
+            }
+            if (!link.anchor().isEmpty()) {
+                builder = builder.param("anchor", link.anchor());
+            }
+            if (!link.media().isEmpty()) {
+                builder = builder.param("media", link.media());
+            }
+            if (!link.hreflang().isEmpty()) {
+                builder = builder.param("hreflang", link.hreflang());
+            }
+            for (InjectLink.Extension ext : link.extensions()) {
+                builder = builder.param(ext.name(), ext.value());
+            }
+            return builder.build();
+        }
+    }
+
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinkDescriptor.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinkDescriptor.java
new file mode 100644
index 0000000..4ee06ff
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinkDescriptor.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import org.glassfish.jersey.linking.mapping.ResourceMappingContext;
+
+/**
+ * Utility for working with @Ref annotations
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+interface InjectLinkDescriptor {
+
+    /**
+     * Get the style
+     * @return the style
+     */
+    InjectLink.Style getLinkStyle();
+
+    /**
+     * Get the link template, either directly from the value() or from the
+     * @Path of the class referenced in resource()
+     * @return the link template
+     */
+    String getLinkTemplate(ResourceMappingContext rmc);
+
+    /**
+     * Get the binding as an EL expression for a particular URI template parameter
+     * @param name
+     * @return the EL binding
+     */
+    String getBinding(String name);
+
+    /**
+     * Get the condition.
+     * @return the condition
+     */
+    String getCondition();
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinkFieldDescriptor.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinkFieldDescriptor.java
new file mode 100644
index 0000000..d6e36f6
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinkFieldDescriptor.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.net.URI;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.ws.rs.BeanParam;
+import javax.ws.rs.HttpMethod;
+import javax.ws.rs.Path;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Link;
+
+import org.glassfish.jersey.linking.mapping.ResourceMappingContext;
+import org.glassfish.jersey.server.model.AnnotatedMethod;
+import org.glassfish.jersey.server.model.MethodList;
+
+/**
+ * Utility class for working with {@link InjectLink} annotated fields.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+class InjectLinkFieldDescriptor extends FieldDescriptor implements InjectLinkDescriptor {
+
+    private InjectLink link;
+    private Class<?> type;
+    private Map<String, String> bindings;
+
+    /**
+     * C'tor
+     *
+     * @param f the field to inject
+     * @param l the InjectLink annotation
+     * @param t the class that contains field f
+     */
+    InjectLinkFieldDescriptor(Field f, InjectLink l, Class<?> t) {
+        super(f);
+        link = l;
+        type = t;
+        bindings = new HashMap<>();
+        for (Binding binding : l.bindings()) {
+            bindings.put(binding.name(), binding.value());
+        }
+    }
+
+    /**
+     * Injects the uri into the field.
+     *
+     * @param instance the target for the injection
+     * @param uri the value to inject
+     */
+    void setPropertyValue(Object instance, URI uri) {
+        setAccessibleField(field);
+        try {
+
+            Object value;
+            if (Objects.equals(URI.class, type)) {
+                value = uri;
+            } else if (Link.class.isAssignableFrom(type)) {
+
+                // Make a link with the correct bindings
+                value = getLink(uri);
+            } else if (Objects.equals(String.class, type)) {
+                value = uri.toString();
+            } else {
+                throw new IllegalArgumentException("Field type " + type + " not one of supported String,URI and Link");
+            }
+
+            field.set(instance, value);
+        } catch (IllegalArgumentException | IllegalAccessException ex) {
+            Logger.getLogger(InjectLinkFieldDescriptor.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+
+    /**
+     * Simple delegate to {@link InjectLink#style()}
+     * @return {@link InjectLink#style()}
+     */
+    @Override
+    public InjectLink.Style getLinkStyle() {
+        return link.style();
+    }
+
+    /**
+     * Returns the template based on the {@link ResourceMappingContext}
+     *
+     * @param rmc the context
+     * @return the link template
+     */
+    @Override
+    public String getLinkTemplate(ResourceMappingContext rmc) {
+        return getLinkTemplate(rmc, link);
+    }
+
+
+    /**
+     * Returns the template based on the {@link ResourceMappingContext}
+     *
+     * @param rmc the context
+     * @param link the link
+     * @return the link template
+     */
+    static String getLinkTemplate(ResourceMappingContext rmc, InjectLink link) {
+        String template = null;
+        if (Objects.equals(link.resource(), Class.class)) {
+            template = link.value();
+        } else {
+            ResourceMappingContext.Mapping map = rmc.getMapping(link.resource());
+            if (map != null) {
+                template = map.getTemplate().getTemplate();
+            } else {
+                // extract template from specified class' @Path annotation
+                Path path = link.resource().getAnnotation(Path.class);
+                template = path == null ? "" : path.value();
+            }
+
+            // extract template from specified class' @Path annotation
+            if (!link.method().isEmpty()) {
+                // append value of method's @Path annotation
+                MethodList methods = new MethodList(link.resource());
+                methods = methods.withMetaAnnotation(HttpMethod.class);
+                for (AnnotatedMethod method : methods) {
+                    if (!Objects.equals(method.getMethod().getName(), link.method())) {
+                        continue;
+                    }
+                    StringBuilder builder = new StringBuilder();
+                    builder.append(template);
+
+                    Path methodPath = method.getAnnotation(Path.class);
+                    if (methodPath != null) {
+                        String methodTemplate = methodPath.value();
+
+                        if (!(template.endsWith("/") || methodTemplate.startsWith("/"))) {
+                            builder.append("/");
+                        }
+                        builder.append(methodTemplate);
+                    }
+
+                    CharSequence querySubString = extractQueryParams(method);
+
+                    if (querySubString.length() > 0) {
+                        builder.append("{?");
+                        builder.append(querySubString);
+                        builder.append("}");
+                    }
+
+                    template = builder.toString();
+                    break;
+                }
+            }
+        }
+
+        return template;
+    }
+
+    static StringBuilder extractQueryParams(AnnotatedMethod method) throws SecurityException {
+        // append query parameters
+        StringBuilder querySubString = new StringBuilder();
+        int parameterIndex = 0;
+        for (Annotation[] paramAnns : method.getParameterAnnotations()) {
+            for (Annotation ann : paramAnns) {
+                if (Objects.equals(ann.annotationType(), QueryParam.class)) {
+                    querySubString.append(((QueryParam) ann).value());
+                    querySubString.append(',');
+                }
+                if (Objects.equals(ann.annotationType(), BeanParam.class)) {
+                    Class<?> beanParamType = method.getParameterTypes()[parameterIndex];
+                    Field[] fields = beanParamType.getFields();
+                    for (Field field : fields) {
+                        QueryParam queryParam = field.getAnnotation(QueryParam.class);
+                        if (queryParam != null) {
+                            querySubString.append(queryParam.value());
+                            querySubString.append(',');
+                        }
+                    }
+                    Method[] beanMethods = beanParamType.getMethods();
+                    for (Method beanMethod : beanMethods) {
+                        QueryParam queryParam = beanMethod.getAnnotation(QueryParam.class);
+                        if (queryParam != null) {
+                            querySubString.append(queryParam.value());
+                            querySubString.append(',');
+                        }
+                    }
+                }
+            }
+            parameterIndex++;
+        }
+
+        return querySubString;
+    }
+
+    /**
+     * Creates a link from uri combined with {@link InjectLink}.
+     *
+     * @param uri uri for the link
+     * @return Link instance
+     */
+    Link getLink(URI uri) {
+        return InjectLink.Util.buildLinkFromUri(uri, link);
+    }
+
+    /**
+     * Gets the binding by name
+     *
+     * @param name name of the binding
+     * @return the binding
+     */
+    public String getBinding(String name) {
+        return bindings.get(name);
+    }
+
+
+    /**
+     * Returns the condition of {@link InjectLink}.
+     * @return {@link InjectLink#condition()}
+     */
+    public String getCondition() {
+        return link.condition();
+    }
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinkNoFollow.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinkNoFollow.java
new file mode 100644
index 0000000..bb83c56
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinkNoFollow.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import org.glassfish.jersey.Beta;
+
+/**
+ * Specifies on a field that should be ignored by Link recursive introspection.
+ *
+ * In some scenarios like with framework contexts or for more control,
+ * it is not wanted to try to find nested links into entities or collections.
+ *
+ * @author Aurelien Thieriot
+ */
+@Target({ElementType.FIELD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Beta
+public @interface InjectLinkNoFollow {
+
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinks.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinks.java
new file mode 100644
index 0000000..6257537
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinks.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.glassfish.jersey.Beta;
+
+/**
+ * Used to request the addition of a set of links, can be used for both
+ * link headers on a Class or injection into a List<Link> or Link[] property.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+@Target({ElementType.TYPE, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+@Beta
+public @interface InjectLinks {
+
+    /**
+     * Container for a set of {@link org.glassfish.jersey.linking.InjectLink} annotations
+     * @return array of {@code InjectLink} elements
+     */
+    InjectLink[] value() default {};
+
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinksFieldDescriptor.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinksFieldDescriptor.java
new file mode 100644
index 0000000..7f4925c
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/InjectLinksFieldDescriptor.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.core.Link;
+
+/**
+ * Utility class for working with {@link InjectLinks} annotated fields.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+class InjectLinksFieldDescriptor extends FieldDescriptor {
+
+    private final InjectLinks link;
+    private final Class<?> type;
+
+    /**
+     * C'tor
+     *
+     * @param f the field to inject
+     * @param l the InjectLinks annotation
+     * @param t the class that contains field f
+     */
+    InjectLinksFieldDescriptor(Field f, InjectLinks l, Class<?> t) {
+        super(f);
+        link = l;
+        type = t;
+    }
+
+    /**
+     * Injects the Link list into the instance.
+     *
+     * If the field is {@code null} then it is replaced with the list.
+     * If the field already contains links, then the content is merged
+     * with this list into a new list and injected.
+     *
+     * @param instance the instance that contains the field f
+     * @param list the list of links to inject
+     */
+    public void setPropertyValue(Object instance, List<Link> list) {
+        setAccessibleField(field);
+        try {
+            List<Link> merged = mergeWithExistingField(instance, list);
+
+            Object value;
+            if (Objects.equals(List.class, type)) {
+                value = merged;
+            } else if (type.isArray()) {
+                value = merged.toArray((Object[]) Array.newInstance(type.getComponentType(), merged.size()));
+            } else {
+                throw new IllegalArgumentException("Field type " + type + " not one of supported List<Link> or Link[]");
+            }
+
+            field.set(instance, value);
+
+
+        } catch (IllegalArgumentException | IllegalAccessException ex) {
+            Logger.getLogger(InjectLinksFieldDescriptor.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+
+    private List<Link> mergeWithExistingField(Object instance, List<Link> list) throws IllegalAccessException {
+        Object existing = field.get(instance);
+        if (existing != null) {
+            if (Collection.class.isAssignableFrom(existing.getClass()) && !((Collection) existing).isEmpty()) {
+                List<Link> merged  = new ArrayList<>(list);
+                merged.addAll((Collection<Link>) existing);
+                return merged;
+            } else if (existing.getClass().isArray() && existing.getClass().isAssignableFrom(Link[].class)) {
+                List<Link> merged = new ArrayList<>(list);
+                merged.addAll(Arrays.asList((Link[]) existing));
+                return merged;
+            }
+        }
+        return list;
+    }
+
+    /**
+     * Creates {@link InjectLinkFieldDescriptor} for each link to inject.
+     */
+    InjectLinkFieldDescriptor[] getLinksToInject() {
+        final InjectLink[] listOfLinks = link.value();
+        InjectLinkFieldDescriptor[] fields = new InjectLinkFieldDescriptor[listOfLinks.length];
+        for (int i = 0; i < fields.length; i++) {
+            fields[i] = new InjectLinkFieldDescriptor(field, listOfLinks[i], Link.class);
+        }
+        return fields;
+    }
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/LinkELContext.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/LinkELContext.java
new file mode 100644
index 0000000..4af9916
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/LinkELContext.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import javax.el.BeanELResolver;
+import javax.el.CompositeELResolver;
+import javax.el.ELContext;
+import javax.el.ELResolver;
+import javax.el.FunctionMapper;
+import javax.el.VariableMapper;
+
+/**
+ * An ELContext that encapsulates the response information for use by the
+ * expression evaluator.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+class LinkELContext extends ELContext {
+
+    private Object entity;
+    private Object resource;
+    private Object instance;
+
+    /**
+     * Convenience constructor for the common case where a context where
+     * the entity and instance are the same. Equivalent to
+     * {@link #LinkELContext(Object, Object, Object)}.
+     *
+     * @param entity
+     * @param resource
+     */
+    LinkELContext(Object entity, Object resource) {
+        this.entity = entity;
+        this.resource = resource;
+        this.instance = entity;
+    }
+
+    /**
+     * Construct a new context
+     * @param entity the entity returned from the resource method
+     * @param resource the resource class instance that returned the entity
+     * @param instance the instance that contains the entity, e.g. the value of
+     * a field within an entity class.
+     */
+    LinkELContext(Object entity, Object resource, Object instance) {
+        this.entity = entity;
+        this.resource = resource;
+        this.instance = instance;
+    }
+
+    @Override
+    public ELResolver getELResolver() {
+        CompositeELResolver resolver = new CompositeELResolver();
+        resolver.add(new ResponseContextResolver(entity, resource, instance));
+        resolver.add(new BeanELResolver(true));
+        return resolver;
+    }
+
+    @Override
+    public FunctionMapper getFunctionMapper() {
+        return null;
+    }
+
+    @Override
+    public VariableMapper getVariableMapper() {
+        return null;
+    }
+
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/LinkHeaderDescriptor.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/LinkHeaderDescriptor.java
new file mode 100644
index 0000000..7e621ad
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/LinkHeaderDescriptor.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.glassfish.jersey.linking.InjectLink.Style;
+import org.glassfish.jersey.linking.mapping.ResourceMappingContext;
+
+/**
+ * Utility class for working with {@link org.glassfish.jersey.linking.InjectLink} annotations.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+class LinkHeaderDescriptor implements InjectLinkDescriptor {
+
+    private InjectLink linkHeader;
+    private Map<String, String> bindings;
+
+    LinkHeaderDescriptor(InjectLink linkHeader) {
+        this.linkHeader = linkHeader;
+        bindings = new HashMap<>();
+        for (Binding binding : linkHeader.bindings()) {
+            bindings.put(binding.name(), binding.value());
+        }
+    }
+
+    InjectLink getLinkHeader() {
+        return linkHeader;
+    }
+
+    public String getLinkTemplate(ResourceMappingContext rmc) {
+        return InjectLinkFieldDescriptor.getLinkTemplate(rmc, linkHeader);
+    }
+
+    public Style getLinkStyle() {
+        return linkHeader.style();
+    }
+
+    public String getBinding(String name) {
+        return bindings.get(name);
+    }
+
+    public String getCondition() {
+        return linkHeader.condition();
+    }
+
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/LinkMessages.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/LinkMessages.java
new file mode 100644
index 0000000..78fae95
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/LinkMessages.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import org.glassfish.jersey.internal.l10n.Localizable;
+import org.glassfish.jersey.internal.l10n.LocalizableMessageFactory;
+import org.glassfish.jersey.internal.l10n.Localizer;
+
+/**
+ * Message for declarative linking
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+class LinkMessages {
+
+    private static final LocalizableMessageFactory messageFactory = new LocalizableMessageFactory(
+            "org.glassfish.jersey.media.linking.internal");
+    private static final Localizer localizer = new Localizer();
+
+    private static Localizable localizableWARNING_LINKFILTER_PROCESSING(Object arg0) {
+        return messageFactory.getMessage("warning.linkfilter.processing", arg0);
+    }
+
+    /**
+     * LinkFilter cannot process class {0}, exception occurred during processing. Class will be ignored in the LinkFilter.
+     *
+     */
+    static String WARNING_LINKFILTER_PROCESSING(Object arg0) {
+        return localizer.localize(localizableWARNING_LINKFILTER_PROCESSING(arg0));
+    }
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ProvideLink.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ProvideLink.java
new file mode 100644
index 0000000..3c00ba0
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ProvideLink.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.net.URI;
+
+import javax.ws.rs.core.Link;
+
+import org.glassfish.jersey.Beta;
+
+/**
+ * Use this on resource methods to contribute links to a representation.
+ *
+ * It is the inverse of {@link InjectLink} instead of annotating the target you annotate the source of the links.
+ * The added benefit is that since you annotate the method you don't need to specify the path to it.
+ *
+ * <p>
+ * <pre>
+ * &#64;ProvideLink(value = Order.class, rel = "self", bindings = @Binding(name = "orderId", value = "${instance.id}"))
+ * &#64;ProvideLink(value = PaymentConfirmation.class, rel = "order",
+ *                  bindings = @Binding(name = "orderId", value = "${instance.orderId}"))
+ * public Response get(@PathParam("orderId") String orderId) { ...
+ * </pre>
+ * </p>
+ *
+ * It can also be used as a meta annotation, see the Javadoc of {@link InheritFromAnnotation} for details.
+ *
+ * @author Leonard Brünings
+ */
+@Target({ ElementType.METHOD, ElementType.TYPE})
+@Repeatable(ProvideLinks.class)
+@Retention(RetentionPolicy.RUNTIME)
+@Beta
+public @interface ProvideLink {
+
+    /**
+     * The style of URI to inject
+     */
+    InjectLink.Style style() default InjectLink.Style.ABSOLUTE_PATH;
+
+    /**
+     * Provide links for representation classes listed here.
+     *
+     * May use {@link InheritFromAnnotation} for Meta-Annotations
+     */
+    Class<?>[] value();
+
+    /**
+     * Specifies the bindings for embedded URI template parameters.
+     *
+     * @see Binding
+     */
+    Binding[] bindings() default {};
+
+    /**
+     * Specifies a boolean EL expression whose value determines whether a Ref is
+     * set (true) or not (false). Omission of a condition will always insert a
+     * ref.
+     */
+    String condition() default "";
+
+    //
+    // Link properties
+    //
+
+    /**
+     * Specifies the relationship.
+     */
+    String rel() default "";
+
+    /**
+     * Specifies the reverse relationship.
+     */
+    String rev() default "";
+
+    /**
+     * Specifies the media type.
+     */
+    String type() default "";
+
+    /**
+     * Specifies the title.
+     */
+    String title() default "";
+
+    /**
+     * Specifies the anchor
+     */
+    String anchor() default "";
+
+    /**
+     * Specifies the media
+     */
+    String media() default "";
+
+    /**
+     * Specifies the lang of the referenced resource
+     */
+    String hreflang() default "";
+
+    /**
+     * Specifies extension parameters as name-value pairs.
+     */
+    InjectLink.Extension[] extensions() default {};
+
+
+    class Util {
+
+        static Link buildLinkFromUri(URI uri, ProvideLink link) {
+
+            javax.ws.rs.core.Link.Builder builder = javax.ws.rs.core.Link.fromUri(uri);
+            if (!link.rel().isEmpty()) {
+                builder = builder.rel(link.rel());
+            }
+            if (!link.rev().isEmpty()) {
+                builder = builder.param("rev", link.rev());
+            }
+            if (!link.type().isEmpty()) {
+                builder = builder.type(link.type());
+            }
+            if (!link.title().isEmpty()) {
+                builder = builder.param("title", link.title());
+            }
+            if (!link.anchor().isEmpty()) {
+                builder = builder.param("anchor", link.anchor());
+            }
+            if (!link.media().isEmpty()) {
+                builder = builder.param("media", link.media());
+            }
+            if (!link.hreflang().isEmpty()) {
+                builder = builder.param("hreflang", link.hreflang());
+            }
+            for (InjectLink.Extension ext : link.extensions()) {
+                builder = builder.param(ext.name(), ext.value());
+            }
+            return builder.build();
+        }
+    }
+
+    /**
+     * Special interface to indicate that the target should be inherited from the annotated annotation.
+     * <p>
+     * <pre>
+     * &#64;ProvideLinks({
+     *   &#64;ProvideLink(value = ProvideLink.InheritFromAnnotation.class, rel = "next", bindings = {
+     *       &#64;Binding(name = "page", value = "${instance.number + 1}"),
+     *       &#64;Binding(name =&#64; "size", value = "${instance.size}"),
+     *     },
+     *     condition = "${instance.nextPageAvailable}"),
+     *   &#64;ProvideLink(value = ProvideLink.InheritFromAnnotation.class, rel = "prev", bindings = {
+     *       &#64;Binding(name = "page", value = "${instance.number - 1}"),
+     *       &#64;Binding(name = "size", value = "${instance.size}"),
+     *     },
+     *     condition = "${instance.previousPageAvailable}")
+     * })
+     * &#64;Target({ElementType.METHOD})
+     * &#64;Retention(RetentionPolicy.RUNTIME)
+     * &#64;Documented
+     * public &#64;interface PageLinks {
+     * Class<?> value();
+     * }
+     * </pre>
+     * </p>
+     * <p>
+     * In this case the value of each {@link ProvideLink} will be the same as {@code PageLinks} value.
+     * </p>
+     */
+    interface InheritFromAnnotation{}
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ProvideLinkDescriptor.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ProvideLinkDescriptor.java
new file mode 100644
index 0000000..a4b6356
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ProvideLinkDescriptor.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.lang.annotation.Annotation;
+import java.net.URI;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.ws.rs.Path;
+import javax.ws.rs.core.Link;
+
+import org.glassfish.jersey.linking.mapping.ResourceMappingContext;
+import org.glassfish.jersey.server.model.AnnotatedMethod;
+import org.glassfish.jersey.server.model.ResourceMethod;
+
+/**
+ * Utility to work with {@link ProvideLink} annotations.
+ *
+ * @author Leonard Brünings
+ */
+public class ProvideLinkDescriptor implements InjectLinkDescriptor {
+    private final ProvideLink provideLink;
+    private final ResourceMethod resource;
+
+    private final Annotation parentAnnotation;
+
+    private final Map<String, String> bindings;
+
+    /**
+     * c'tor
+     *
+     * @param resource the annotated resource method
+     * @param provideLink the annotaion
+     * @param parentAnnotation the parent annotation if present or {@code null}
+     */
+    public ProvideLinkDescriptor(ResourceMethod resource, ProvideLink provideLink, Annotation parentAnnotation) {
+        this.provideLink = provideLink;
+        this.resource = resource;
+        this.parentAnnotation = parentAnnotation;
+        bindings = new HashMap<>();
+        for (Binding binding : provideLink.bindings()) {
+            bindings.put(binding.name(), binding.value());
+        }
+    }
+
+    /**
+     * @return the annotation
+     */
+    public ProvideLink getProvideLink() {
+        return provideLink;
+    }
+
+    /**
+     * @return the annotated resource method
+     */
+    public ResourceMethod getResource() {
+        return resource;
+    }
+
+    /**
+     * Get the style
+     *
+     * @return the style
+     */
+    public InjectLink.Style getLinkStyle() {
+        return provideLink.style();
+    }
+
+    /**
+     * Get the link template, either directly from the value() or from the
+     * {@code @Path} of the class referenced in resource()
+     *
+     * @return the link template
+     */
+    @Override
+    public String getLinkTemplate(ResourceMappingContext rmc) {
+        String template = null;
+        ResourceMappingContext.Mapping map = rmc.getMapping(resource.getInvocable().getHandler().getHandlerClass());
+        if (map != null) {
+            template = map.getTemplate().getTemplate();
+        } else {
+            // extract template from specified class' @Path annotation
+            Path path = resource.getInvocable().getHandler().getHandlerClass().getAnnotation(Path.class);
+            template = path == null ? "" : path.value();
+        }
+        StringBuilder builder = new StringBuilder(template);
+
+        Path methodPath = resource.getInvocable().getDefinitionMethod().getAnnotation(Path.class);
+        if (methodPath != null) {
+            String methodTemplate = methodPath.value();
+
+            if (!(template.endsWith("/") || methodTemplate.startsWith("/"))) {
+                builder.append("/");
+            }
+            builder.append(methodTemplate);
+        }
+
+        CharSequence querySubString = InjectLinkFieldDescriptor.extractQueryParams(
+                new AnnotatedMethod(resource.getInvocable().getDefinitionMethod()));
+
+        if (querySubString.length() > 0) {
+            builder.append("{?");
+            builder.append(querySubString);
+            builder.append("}");
+        }
+
+        template = builder.toString();
+
+        return template;
+    }
+
+    /**
+     * Get the binding as an EL expression for a particular URI template parameter
+     *
+     * @param name binding name.
+     * @return the EL binding.
+     */
+    @Override
+    public String getBinding(String name) {
+        return bindings.get(name);
+    }
+
+    /**
+     * Get the condition.
+     *
+     * @return the condition
+     */
+    @Override
+    public String getCondition() {
+        return provideLink.condition();
+    }
+
+    /**
+     * Builds a link from a {@link URI}.
+     *
+     * @param uri base URI
+     * @return the {@link Link} instance
+     */
+    public Link getLink(URI uri) {
+        return ProvideLink.Util.buildLinkFromUri(uri, provideLink);
+    }
+
+    /**
+     * @return the parent annotation or {@code null}
+     */
+    public Annotation getParentAnnotation() {
+        return parentAnnotation;
+    }
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ProvideLinks.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ProvideLinks.java
new file mode 100644
index 0000000..9e752ee
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ProvideLinks.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.glassfish.jersey.Beta;
+
+/**
+ * Container for repeatable annotation, see {@link ProvideLink} for details.
+ *
+ * @author Leonard Brünings
+ */
+@Target({ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Beta
+public @interface ProvideLinks {
+
+    /**
+     * Container for a set of {@link ProvideLink} annotations
+     * @return array of {@code ProvideLink} elements
+     */
+    ProvideLink[] value() default {};
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/RequestLinkFilter.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/RequestLinkFilter.java
new file mode 100644
index 0000000..0e234fa
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/RequestLinkFilter.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.io.IOException;
+
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.container.ContainerRequestFilter;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.Link;
+
+import org.glassfish.jersey.server.ExtendedUriInfo;
+
+/**
+ * Filter that processes {@link Link} annotated fields in returned response
+ * entities.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ * @see Link
+ */
+class RequestLinkFilter implements ContainerRequestFilter {
+
+    @Context
+    private ExtendedUriInfo uriInfo;
+
+    @Override
+    public void filter(ContainerRequestContext requestContext) throws IOException {
+
+    }
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ResponseContextResolver.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ResponseContextResolver.java
new file mode 100644
index 0000000..48f8546
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ResponseContextResolver.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.beans.FeatureDescriptor;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import javax.el.ELContext;
+import javax.el.ELResolver;
+import javax.el.PropertyNotWritableException;
+
+/**
+ * The initial context resolver that resolves the entity and resource
+ * objects used at the start of an EL expression.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+class ResponseContextResolver extends ELResolver {
+
+    private Map<String, Object> responseObjects;
+    private static final String ENTITY_OBJECT = "entity";
+    private static final String RESOURCE_OBJECT = "resource";
+    static final String INSTANCE_OBJECT = "instance";
+
+    ResponseContextResolver(Object entity, Object resource, Object instance) {
+        responseObjects = new HashMap<>();
+        responseObjects.put(ENTITY_OBJECT, entity);
+        responseObjects.put(RESOURCE_OBJECT, resource);
+        responseObjects.put(INSTANCE_OBJECT, instance);
+    }
+
+    private boolean isHandled(ELContext elc, Object base, Object property) {
+        if (base != null) {
+            return false;
+        }
+        if (responseObjects.containsKey(property.toString())) {
+            elc.setPropertyResolved(true);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public Object getValue(ELContext elc, Object base, Object property) {
+        if (isHandled(elc, base, property)) {
+            return responseObjects.get(property.toString());
+        }
+        return null;
+    }
+
+    @Override
+    public Class<?> getType(ELContext elc, Object o, Object o1) {
+        if (isHandled(elc, o, o1)) {
+            return getValue(elc, o, o1).getClass();
+        }
+        return null;
+    }
+
+    @Override
+    public void setValue(ELContext elc, Object o, Object o1, Object o2) {
+        throw new PropertyNotWritableException(o2.toString());
+    }
+
+    @Override
+    public boolean isReadOnly(ELContext elc, Object o, Object o1) {
+        if (isHandled(elc, o, o1)) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public Iterator<FeatureDescriptor> getFeatureDescriptors(ELContext elc, Object o) {
+        return null;
+    }
+
+    @Override
+    public Class<?> getCommonPropertyType(ELContext elc, Object o) {
+        return Object.class;
+    }
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ResponseLinkFilter.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ResponseLinkFilter.java
new file mode 100644
index 0000000..24d83d6
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/ResponseLinkFilter.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.container.ContainerResponseContext;
+import javax.ws.rs.container.ContainerResponseFilter;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.Link;
+import javax.ws.rs.core.UriInfo;
+
+import org.glassfish.jersey.linking.contributing.ResourceLinkContributionContext;
+import org.glassfish.jersey.linking.mapping.ResourceMappingContext;
+
+/**
+ * Filter that processes {@link Link} annotated fields in returned response
+ * entities.
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ * @see Link
+ */
+class ResponseLinkFilter implements ContainerResponseFilter {
+
+    @Context
+    private UriInfo uriInfo;
+
+    @Context
+    private ResourceMappingContext rmc;
+
+    @Context
+    private ResourceLinkContributionContext rlcc;
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void filter(ContainerRequestContext request, ContainerResponseContext response) {
+        final Object entity = response.getEntity();
+
+        if (entity != null && !uriInfo.getMatchedResources().isEmpty()) {
+            Class<?> entityClass = entity.getClass();
+            HeaderProcessor lhp = new HeaderProcessor(entityClass);
+            lhp.processLinkHeaders(entity, uriInfo, rmc, response.getHeaders());
+            FieldProcessor lp = new FieldProcessor(entityClass);
+            lp.processLinks(entity, uriInfo, rmc, rlcc);
+        }
+
+    }
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/contributing/NaiveResourceLinkContributionContext.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/contributing/NaiveResourceLinkContributionContext.java
new file mode 100644
index 0000000..ad492b1
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/contributing/NaiveResourceLinkContributionContext.java
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.contributing;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.ws.rs.core.Context;
+
+import org.glassfish.jersey.linking.ProvideLink;
+import org.glassfish.jersey.linking.ProvideLinkDescriptor;
+import org.glassfish.jersey.linking.ProvideLinks;
+import org.glassfish.jersey.server.ExtendedResourceContext;
+import org.glassfish.jersey.server.model.HandlerConstructor;
+import org.glassfish.jersey.server.model.Invocable;
+import org.glassfish.jersey.server.model.MethodHandler;
+import org.glassfish.jersey.server.model.Resource;
+import org.glassfish.jersey.server.model.ResourceMethod;
+import org.glassfish.jersey.server.model.ResourceModel;
+import org.glassfish.jersey.server.model.ResourceModelComponent;
+import org.glassfish.jersey.server.model.ResourceModelVisitor;
+import org.glassfish.jersey.server.model.RuntimeResource;
+
+/**
+ * Simple map based implementation of the ResourceLinkContributionContext.
+ *
+ * @author Leonard Brünings
+ */
+public class NaiveResourceLinkContributionContext implements ResourceLinkContributionContext {
+
+    private final ExtendedResourceContext erc;
+
+    /**
+     * Mappings holds a single-level mapping between a class, and it's {@link ProvideLinkDescriptor}s
+     */
+    private Map<Class<?>, List<ProvideLinkDescriptor>> mappings;
+
+    /**
+     * Contributions holds all contributions for a class, this includes all contributions from it's ancestors.
+     */
+    private Map<Class<?>, List<ProvideLinkDescriptor>> contributions = new ConcurrentHashMap<>();
+
+    /**
+     * C'tor
+     * @param erc the ExtendedResourceContext
+     */
+    public NaiveResourceLinkContributionContext(@Context final ExtendedResourceContext erc) {
+        this.erc = erc;
+    }
+
+    @Override
+    public List<ProvideLinkDescriptor> getContributorsFor(Class<?> entityClass) {
+        buildMappings();
+        return contributions.computeIfAbsent(entityClass,
+                aClass -> Collections.unmodifiableList(collectContributors(aClass, new ArrayList<>())));
+    }
+
+    /**
+     * Collects contributors for a class recursively up the ancestors chain.
+     *
+     * @param entityClass the class to
+     * @param contributors collector list
+     * @return contributors list for easier use in lambdas
+     */
+    private List<ProvideLinkDescriptor> collectContributors(Class<?> entityClass, List<ProvideLinkDescriptor> contributors) {
+        contributors.addAll(mappings.getOrDefault(entityClass, Collections.emptyList()));
+        Class<?> sc = entityClass.getSuperclass();
+        if (sc != null && sc != Object.class) {
+            collectContributors(sc, contributors);
+        }
+        return contributors;
+    }
+
+    private void buildMappings() {
+        if (mappings != null) {
+            return;
+        }
+        final Map<Class<?>, List<ProvideLinkDescriptor>> newMappings = new HashMap<>();
+
+        erc.getResourceModel().accept(new ResourceModelVisitor() {
+
+            private void processComponents(final ResourceModelComponent component) {
+
+                final List<? extends ResourceModelComponent> components = component.getComponents();
+                if (components != null) {
+                    for (final ResourceModelComponent rc : components) {
+                        rc.accept(this);
+                    }
+                }
+            }
+
+            @Override
+            public void visitInvocable(final Invocable invocable) {
+                processComponents(invocable);
+            }
+
+            @Override
+            public void visitRuntimeResource(final RuntimeResource runtimeResource) {
+                processComponents(runtimeResource);
+            }
+
+            @Override
+            public void visitResourceModel(final ResourceModel resourceModel) {
+                processComponents(resourceModel);
+            }
+
+            @Override
+            public void visitResourceHandlerConstructor(final HandlerConstructor handlerConstructor) {
+                processComponents(handlerConstructor);
+            }
+
+            @Override
+            public void visitMethodHandler(final MethodHandler methodHandler) {
+                processComponents(methodHandler);
+            }
+
+            @Override
+            public void visitChildResource(final Resource resource) {
+                processComponents(resource);
+            }
+
+            @Override
+            public void visitResource(final Resource resource) {
+                processComponents(resource);
+            }
+
+            @Override
+            public void visitResourceMethod(final ResourceMethod resourceMethod) {
+
+                if (resourceMethod.isExtended()) {
+                    return;
+                }
+
+                if (resourceMethod.getInvocable() != null) {
+                    final Invocable i = resourceMethod.getInvocable();
+
+                    Method method = i.getDefinitionMethod();
+
+                    List<ProvideLinkDescriptor> linkDescriptors = new ArrayList<>();
+
+                    handleMetaAnnotations(resourceMethod, method, linkDescriptors);
+
+                    handleAnnotations(resourceMethod, linkDescriptors, method, null);
+
+                    for (ProvideLinkDescriptor linkDescriptor : linkDescriptors) {
+                        for (Class<?> target : linkDescriptor.getProvideLink().value()) {
+                            target = handleInheritedTarget(linkDescriptor, target);
+                            newMappings.computeIfAbsent(target, aClass -> new ArrayList<>()).add(linkDescriptor);
+                        }
+                    }
+                }
+
+                processComponents(resourceMethod);
+            }
+
+            private Class<?> handleInheritedTarget(ProvideLinkDescriptor linkDescriptor, Class<?> target) {
+                if (Objects.equals(ProvideLink.InheritFromAnnotation.class, target)) {
+                    Annotation parentAnnotation = linkDescriptor.getParentAnnotation();
+                    if (parentAnnotation == null) {
+                        throw new IllegalArgumentException("InheritFromAnnotation can only be used for Annotations");
+                    }
+                    return findTarget(parentAnnotation);
+                }
+                return target;
+            }
+
+            private Class<?> findTarget(Annotation parentAnnotation) {
+                Method[] methods = parentAnnotation.annotationType().getDeclaredMethods();
+                for (Method method : methods) {
+                    if (method.isAccessible() || Class.class.isAssignableFrom(method.getReturnType())) {
+
+                        try {
+                            return (Class<?>) method.invoke(parentAnnotation);
+                        } catch (IllegalArgumentException | IllegalAccessException | InvocationTargetException ex) {
+                            Logger.getLogger(NaiveResourceLinkContributionContext.class.getName()).log(Level.FINE, null, ex);
+                        }
+
+                    }
+                }
+                throw new IllegalArgumentException("No suitable element of type Class<?> found on: "
+                        + parentAnnotation.getClass());
+            }
+
+            private void handleMetaAnnotations(ResourceMethod resourceMethod, Method method,
+                    List<ProvideLinkDescriptor> linkDescriptors) {
+                Annotation[] annotations = method.getDeclaredAnnotations();
+                for (Annotation annotation : annotations) {
+                    handleAnnotations(resourceMethod, linkDescriptors, annotation.annotationType(), annotation);
+                }
+            }
+
+            private void handleAnnotations(ResourceMethod resourceMethod, List<ProvideLinkDescriptor> linkDescriptors,
+                    AnnotatedElement element, Annotation parentAnnotation) {
+                if (element.isAnnotationPresent(ProvideLink.class) || element.isAnnotationPresent(ProvideLinks.class)) {
+                    ProvideLink provideLink = element.getAnnotation(ProvideLink.class);
+                    if (provideLink != null) {
+                        linkDescriptors.add(new ProvideLinkDescriptor(resourceMethod, provideLink, parentAnnotation));
+                    }
+                    ProvideLinks provideLinks = element.getAnnotation(ProvideLinks.class);
+                    if (provideLinks != null) {
+                        for (ProvideLink link : provideLinks.value()) {
+                            linkDescriptors.add(new ProvideLinkDescriptor(resourceMethod, link, parentAnnotation));
+                        }
+                    }
+
+                }
+            }
+
+        });
+
+        mappings = newMappings;
+    }
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/contributing/ResourceLinkContributionContext.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/contributing/ResourceLinkContributionContext.java
new file mode 100644
index 0000000..9a4aaf5
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/contributing/ResourceLinkContributionContext.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.contributing;
+
+import java.util.List;
+
+import org.glassfish.jersey.linking.ProvideLinkDescriptor;
+
+/**
+ * The ResourceLinkContributionContext provides access for link contributions from other sources to an entity.
+ *
+ * @author Leonard Brünings
+ */
+public interface ResourceLinkContributionContext {
+
+    /**
+     * Returns all link contributions for an entity class.
+     *
+     * It also includes contributions for every ancestor of entityClass.
+     *
+     * @param entityClass the entityClass
+     * @return list of link contributions to add to the class
+     */
+    List<ProvideLinkDescriptor> getContributorsFor(Class<?> entityClass);
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/mapping/NaiveResourceMappingContext.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/mapping/NaiveResourceMappingContext.java
new file mode 100644
index 0000000..46f7617
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/mapping/NaiveResourceMappingContext.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.mapping;
+
+import java.lang.reflect.Type;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import javax.ws.rs.core.Context;
+
+import org.glassfish.jersey.process.Inflector;
+import org.glassfish.jersey.server.ExtendedResourceContext;
+import org.glassfish.jersey.server.model.HandlerConstructor;
+import org.glassfish.jersey.server.model.Invocable;
+import org.glassfish.jersey.server.model.MethodHandler;
+import org.glassfish.jersey.server.model.Resource;
+import org.glassfish.jersey.server.model.ResourceMethod;
+import org.glassfish.jersey.server.model.ResourceModel;
+import org.glassfish.jersey.server.model.ResourceModelComponent;
+import org.glassfish.jersey.server.model.ResourceModelVisitor;
+import org.glassfish.jersey.server.model.RuntimeResource;
+import org.glassfish.jersey.uri.PathPattern;
+import org.glassfish.jersey.uri.UriTemplate;
+
+/**
+ * This implementation of the resource mapping context assumed resources are
+ * of a simple type with a statically defined structure.
+ *
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+
+public class NaiveResourceMappingContext implements ResourceMappingContext {
+
+    private final ExtendedResourceContext erc;
+
+    private Map<Class<?>, ResourceMappingContext.Mapping> mappings;
+
+    public NaiveResourceMappingContext(@Context final ExtendedResourceContext erc) {
+        this.erc = erc;
+    }
+
+    @Override
+    public Mapping getMapping(final Class<?> resource) {
+        buildMappings();
+        return mappings.get(resource);
+    }
+
+    private void buildMappings() {
+        if (mappings != null) {
+            return;
+        }
+        mappings = new HashMap<>();
+
+        erc.getResourceModel().accept(new ResourceModelVisitor() {
+
+            Deque<PathPattern> stack = new LinkedList<>();
+
+            private void processComponents(final ResourceModelComponent component) {
+
+                final List<? extends ResourceModelComponent> components = component.getComponents();
+                if (components != null) {
+                    for (final ResourceModelComponent rc : components) {
+                        rc.accept(this);
+                    }
+                }
+            }
+
+            @Override
+            public void visitInvocable(final Invocable invocable) {
+                processComponents(invocable);
+            }
+
+            @Override
+            public void visitRuntimeResource(final RuntimeResource runtimeResource) {
+                processComponents(runtimeResource);
+            }
+
+            @Override
+            public void visitResourceModel(final ResourceModel resourceModel) {
+                processComponents(resourceModel);
+            }
+
+            @Override
+            public void visitResourceHandlerConstructor(final HandlerConstructor handlerConstructor) {
+                processComponents(handlerConstructor);
+            }
+
+            @Override
+            public void visitMethodHandler(final MethodHandler methodHandler) {
+                processComponents(methodHandler);
+            }
+
+            @Override
+            public void visitChildResource(final Resource resource) {
+                visitResourceIntl(resource, false);
+            }
+
+            @Override
+            public void visitResource(final Resource resource) {
+
+                visitResourceIntl(resource, true);
+            }
+
+            private void visitResourceIntl(final Resource resource, final boolean isRoot) {
+                try {
+                    stack.addLast(resource.getPathPattern());
+                    processComponents(resource);
+
+                    if (isRoot) {
+                        Class likelyToBeRoot = null;
+                        for (final Class next : resource.getHandlerClasses()) {
+                            if (!(Inflector.class.isAssignableFrom(next))) {
+                                likelyToBeRoot = next;
+                            }
+                        }
+
+                        if (likelyToBeRoot != null) {
+                            mappings.put(likelyToBeRoot, getMapping(getTemplate()));
+                        }
+                    }
+                } finally {
+                    stack.removeLast();
+                }
+            }
+
+            @Override
+            public void visitResourceMethod(final ResourceMethod resourceMethod) {
+
+                if (resourceMethod.isExtended()) {
+                    return;
+                }
+
+                if (ResourceMethod.JaxrsType.SUB_RESOURCE_LOCATOR.equals(resourceMethod.getType())) {
+                    if (resourceMethod.getInvocable() != null) {
+                        final Invocable i = resourceMethod.getInvocable();
+
+                        final Type type = i.getResponseType();
+                        final StringBuilder template = getTemplate();
+
+                        mappings.put((Class) type, getMapping(template));
+
+                        // Process sub resources ?
+
+                        Resource.Builder builder = Resource
+                                .builder(i.getRawResponseType());
+                        if (builder == null) {
+                            // for example in the case the return type of the sub resource locator is Object
+                            builder = Resource.builder().path(resourceMethod.getParent().getPath());
+                        }
+                        final Resource subResource = builder.build();
+
+                        visitChildResource(subResource);
+                    }
+                }
+
+                processComponents(resourceMethod);
+            }
+
+            private StringBuilder getTemplate() {
+                final StringBuilder template = new StringBuilder();
+                for (final PathPattern pp : stack) {
+                    final String ppTemplate = pp.getTemplate().getTemplate();
+
+                    final int tlength = template.length();
+                    if (tlength > 0) {
+                        if (template.charAt(tlength - 1) == '/') {
+                            if (ppTemplate.startsWith("/")) {
+                                template.append(ppTemplate, 1, ppTemplate.length());
+                            } else {
+                                template.append(ppTemplate);
+                            }
+                        } else {
+                            if (ppTemplate.startsWith("/")) {
+                                template.append(ppTemplate);
+                            } else {
+                                template.append("/");
+                                template.append(ppTemplate);
+                            }
+                        }
+                    } else {
+                        template.append(ppTemplate);
+                    }
+
+                }
+                return template;
+            }
+        });
+
+    }
+
+    private Mapping getMapping(final StringBuilder template) {
+        return new Mapping() {
+            UriTemplate uriTemplate = new UriTemplate(template.toString());
+
+            @Override
+            public UriTemplate getTemplate() {
+                return uriTemplate;
+            }
+        };
+    }
+
+}
diff --git a/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/mapping/ResourceMappingContext.java b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/mapping/ResourceMappingContext.java
new file mode 100644
index 0000000..9d04d89
--- /dev/null
+++ b/incubator/declarative-linking/src/main/java/org/glassfish/jersey/linking/mapping/ResourceMappingContext.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.mapping;
+
+import org.glassfish.jersey.uri.UriTemplate;
+
+/**
+ * This service tries to work out the UriTemplate required for a particular
+ * resource class.
+ *
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+
+public interface ResourceMappingContext {
+
+    public interface Mapping {
+
+        public UriTemplate getTemplate();
+    }
+
+    public Mapping getMapping(Class<?> resource);
+}
diff --git a/incubator/declarative-linking/src/main/resources/org/glassfish/jersey/media/linking/internal/linkMessages.properties b/incubator/declarative-linking/src/main/resources/org/glassfish/jersey/media/linking/internal/linkMessages.properties
new file mode 100644
index 0000000..681e193
--- /dev/null
+++ b/incubator/declarative-linking/src/main/resources/org/glassfish/jersey/media/linking/internal/linkMessages.properties
@@ -0,0 +1,18 @@
+#
+# Copyright (c) 2014, 2018 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+warning.linkfilter.processing=LinkFilter cannot process class {0}, exception occurred during processing. Class will be ignored \
+  in the LinkFilter.
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/EntityDescriptorTest.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/EntityDescriptorTest.java
new file mode 100644
index 0000000..5ed63fd
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/EntityDescriptorTest.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.net.URI;
+import java.util.Iterator;
+
+import javax.ws.rs.Path;
+import javax.ws.rs.core.UriBuilder;
+
+import org.glassfish.jersey.linking.mapping.ResourceMappingContext;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+/**
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+public class EntityDescriptorTest {
+
+    public static class TestClassA {
+
+        @InjectLink
+        protected String foo;
+
+        @InjectLink
+        private String bar;
+
+        public String baz;
+    }
+
+    ResourceMappingContext mockRmc = new ResourceMappingContext() {
+
+        @Override
+        public ResourceMappingContext.Mapping getMapping(Class<?> resource) {
+            return null;
+        }
+    };
+
+    /**
+     * Test for declared properties
+     */
+    @Test
+    public void testDeclaredProperties() {
+        System.out.println("Declared properties");
+        EntityDescriptor instance = EntityDescriptor.getInstance(TestClassA.class);
+        assertEquals(2, instance.getLinkFields().size());
+        assertEquals(1, instance.getNonLinkFields().size());
+    }
+
+    public static class TestClassB extends TestClassA {
+
+        @InjectLink
+        private String bar;
+    }
+
+    /**
+     * Test for inherited properties
+     */
+    @Test
+    public void testInheritedProperties() {
+        System.out.println("Inherited properties");
+        EntityDescriptor instance = EntityDescriptor.getInstance(TestClassB.class);
+        assertEquals(2, instance.getLinkFields().size());
+        assertEquals(1, instance.getNonLinkFields().size());
+    }
+
+    private static final String TEMPLATE_A = "foo";
+
+    @Path(TEMPLATE_A)
+    public static class TestResourceA {
+    }
+
+    public static class TestClassC {
+
+        @InjectLink(resource = TestResourceA.class, bindings = {@Binding(name = "bar", value = "baz")})
+        String res;
+    }
+
+    @Test
+    public void testResourceLink() {
+        System.out.println("Resource class link");
+        EntityDescriptor instance = EntityDescriptor.getInstance(TestClassC.class);
+        assertEquals(1, instance.getLinkFields().size());
+        assertEquals(0, instance.getNonLinkFields().size());
+        InjectLinkFieldDescriptor linkDesc = (InjectLinkFieldDescriptor) instance.getLinkFields().iterator().next();
+        assertEquals(TEMPLATE_A, linkDesc.getLinkTemplate(mockRmc));
+        assertEquals("baz", linkDesc.getBinding("bar"));
+    }
+
+    public static class TestClassD {
+
+        @InjectLink(value = TEMPLATE_A, style = InjectLink.Style.RELATIVE_PATH)
+        private String res1;
+
+        @InjectLink(value = TEMPLATE_A, style = InjectLink.Style.RELATIVE_PATH)
+        private URI res2;
+    }
+
+    @Test
+    public void testStringLink() {
+        System.out.println("String link");
+        EntityDescriptor instance = EntityDescriptor.getInstance(TestClassD.class);
+        assertEquals(2, instance.getLinkFields().size());
+        assertEquals(0, instance.getNonLinkFields().size());
+        Iterator<FieldDescriptor> i = instance.getLinkFields().iterator();
+        while (i.hasNext()) {
+            InjectLinkFieldDescriptor linkDesc = (InjectLinkFieldDescriptor) i.next();
+            assertEquals(TEMPLATE_A, linkDesc.getLinkTemplate(mockRmc));
+        }
+    }
+
+    @Test
+    public void testSetLink() {
+        System.out.println("Set link");
+        EntityDescriptor instance = EntityDescriptor.getInstance(TestClassD.class);
+        Iterator<FieldDescriptor> i = instance.getLinkFields().iterator();
+        TestClassD testClass = new TestClassD();
+        while (i.hasNext()) {
+            InjectLinkFieldDescriptor linkDesc = (InjectLinkFieldDescriptor) i.next();
+            URI value = UriBuilder.fromPath(linkDesc.getLinkTemplate(mockRmc)).build();
+            linkDesc.setPropertyValue(testClass, value);
+        }
+        assertEquals(TEMPLATE_A, testClass.res1);
+        assertEquals(TEMPLATE_A, testClass.res2.toString());
+    }
+
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/FieldProcessorTest.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/FieldProcessorTest.java
new file mode 100644
index 0000000..e0afeba
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/FieldProcessorTest.java
@@ -0,0 +1,853 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.net.URI;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Filter;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import java.util.regex.MatchResult;
+import java.util.zip.ZipEntry;
+import javax.ws.rs.BeanParam;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Link;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.PathSegment;
+import javax.ws.rs.core.UriBuilder;
+
+import javax.xml.bind.annotation.XmlTransient;
+
+import org.glassfish.jersey.internal.util.collection.MultivaluedStringMap;
+import org.glassfish.jersey.linking.contributing.ResourceLinkContributionContext;
+import org.glassfish.jersey.linking.mapping.ResourceMappingContext;
+import org.glassfish.jersey.server.ExtendedUriInfo;
+import org.glassfish.jersey.server.model.Resource;
+import org.glassfish.jersey.server.model.ResourceMethod;
+import org.glassfish.jersey.server.model.RuntimeResource;
+import org.glassfish.jersey.uri.UriTemplate;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+public class FieldProcessorTest {
+
+    private static final Logger LOG = Logger.getLogger(FieldProcessor.class.getName());
+
+    ExtendedUriInfo mockUriInfo = new ExtendedUriInfo() {
+
+        private static final String baseURI = "http://example.com/application/resources";
+
+        private MultivaluedMap queryParams = new MultivaluedStringMap();
+
+        @Override
+        public String getPath() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public String getPath(boolean decode) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public List<PathSegment> getPathSegments() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public List<PathSegment> getPathSegments(boolean decode) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public URI getRequestUri() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public UriBuilder getRequestUriBuilder() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public URI getAbsolutePath() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public UriBuilder getAbsolutePathBuilder() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public URI getBaseUri() {
+            return getBaseUriBuilder().build();
+        }
+
+        @Override
+        public UriBuilder getBaseUriBuilder() {
+            return UriBuilder.fromUri(baseURI);
+        }
+
+        @Override
+        public MultivaluedMap<String, String> getPathParameters() {
+            return new MultivaluedStringMap();
+        }
+
+        @Override
+        public MultivaluedMap<String, String> getPathParameters(boolean decode) {
+            return new MultivaluedStringMap();
+        }
+
+        @Override
+        public MultivaluedMap<String, String> getQueryParameters() {
+            return queryParams;
+        }
+
+        @Override
+        public MultivaluedMap<String, String> getQueryParameters(boolean decode) {
+            return queryParams;
+        }
+
+        @Override
+        public List<String> getMatchedURIs() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public List<String> getMatchedURIs(boolean decode) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public List<Object> getMatchedResources() {
+            Object dummyResource = new Object() {
+            };
+            return Collections.singletonList(dummyResource);
+        }
+
+        @Override
+        public Throwable getMappedThrowable() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public List<MatchResult> getMatchedResults() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public List<UriTemplate> getMatchedTemplates() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public List<PathSegment> getPathSegments(String name) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public List<PathSegment> getPathSegments(String name, boolean decode) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public List<RuntimeResource> getMatchedRuntimeResources() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public ResourceMethod getMatchedResourceMethod() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public Resource getMatchedModelResource() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public List<ResourceMethod> getMatchedResourceLocators() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public List<Resource> getLocatorSubResources() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public URI resolve(URI uri) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public URI relativize(URI uri) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+    };
+
+    private final ResourceMappingContext mockRmc = new ResourceMappingContext() {
+
+        @Override
+        public ResourceMappingContext.Mapping getMapping(Class<?> resource) {
+            return null;
+        }
+    };
+
+    protected final ResourceLinkContributionContext mockRlcc = new ResourceLinkContributionContext() {
+        @Override
+        public List<ProvideLinkDescriptor> getContributorsFor(Class<?> entityClass) {
+            return Collections.emptyList();
+        }
+    };
+
+    private static final String TEMPLATE_A = "foo";
+
+    public static class TestClassD {
+
+        @InjectLink(value = TEMPLATE_A, style = InjectLink.Style.RELATIVE_PATH)
+        private String res1;
+
+        @InjectLink(value = TEMPLATE_A, style = InjectLink.Style.RELATIVE_PATH)
+        private URI res2;
+    }
+
+    @Test
+    public void testProcessLinks() {
+        LOG.info("Links");
+
+        FieldProcessor<TestClassD> instance = new FieldProcessor(TestClassD.class);
+        TestClassD testClass = new TestClassD();
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals(TEMPLATE_A, testClass.res1);
+        assertEquals(TEMPLATE_A, testClass.res2.toString());
+    }
+
+    private static final String TEMPLATE_B = "widgets/{id}";
+
+    public static class TestClassE {
+
+        @InjectLink(value = TEMPLATE_B, style = InjectLink.Style.RELATIVE_PATH)
+        private String link;
+
+        private String id;
+
+        public TestClassE(String id) {
+            this.id = id;
+        }
+
+        public String getId() {
+            return id;
+        }
+    }
+
+    @Test
+    public void testProcessLinksWithFields() {
+        LOG.info("Links from field values");
+        FieldProcessor<TestClassE> instance = new FieldProcessor(TestClassE.class);
+        TestClassE testClass = new TestClassE("10");
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("widgets/10", testClass.link);
+    }
+
+    public static class TestClassF {
+
+        @InjectLink(value = TEMPLATE_B, style = InjectLink.Style.RELATIVE_PATH)
+        private String thelink;
+
+        private String id;
+        private TestClassE nested;
+
+        public TestClassF(String id, TestClassE e) {
+            this.id = id;
+            this.nested = e;
+        }
+
+        public String getId() {
+            return id;
+        }
+    }
+
+    @Test
+    public void testNesting() {
+        LOG.info("Nesting");
+        FieldProcessor<TestClassF> instance = new FieldProcessor(TestClassF.class);
+        TestClassE nested = new TestClassE("10");
+        TestClassF testClass = new TestClassF("20", nested);
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("widgets/20", testClass.thelink);
+        assertEquals("widgets/10", testClass.nested.link);
+    }
+
+    @Test
+    public void testArray() {
+        LOG.info("Array");
+        FieldProcessor<TestClassE[]> instance = new FieldProcessor(TestClassE[].class);
+        TestClassE item1 = new TestClassE("10");
+        TestClassE item2 = new TestClassE("20");
+        TestClassE array[] = {item1, item2};
+        instance.processLinks(array, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("widgets/10", array[0].link);
+        assertEquals("widgets/20", array[1].link);
+    }
+
+    @Test
+    public void testCollection() {
+        LOG.info("Collection");
+        FieldProcessor<List> instance = new FieldProcessor(List.class);
+        TestClassE item1 = new TestClassE("10");
+        TestClassE item2 = new TestClassE("20");
+        List<TestClassE> list = Arrays.asList(item1, item2);
+        instance.processLinks(list, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("widgets/10", list.get(0).link);
+        assertEquals("widgets/20", list.get(1).link);
+    }
+
+    @Test
+    public void testMap() {
+        LOG.info("Map");
+        FieldProcessor<Map> instance = new FieldProcessor(Map.class);
+        TestClassE item1 = new TestClassE("10");
+        TestClassE item2 = new TestClassE("20");
+        Map<String, TestClassE> map = new HashMap<>();
+        for (TestClassE item : Arrays.asList(item1, item2)) {
+            map.put(item.getId(), item);
+        }
+        instance.processLinks(map, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("widgets/10", map.get("10").link);
+        assertEquals("widgets/20", map.get("20").link);
+    }
+
+    public static class TestClassG {
+
+        @InjectLink(value = TEMPLATE_B, style = InjectLink.Style.RELATIVE_PATH)
+        private String relativePath;
+
+        @InjectLink(value = TEMPLATE_B, style = InjectLink.Style.ABSOLUTE_PATH)
+        private String absolutePath;
+
+        @InjectLink(value = TEMPLATE_B, style = InjectLink.Style.ABSOLUTE)
+        private String absolute;
+
+        @InjectLink(TEMPLATE_B)
+        private String defaultStyle;
+
+        private String id;
+
+        public TestClassG(String id) {
+            this.id = id;
+        }
+
+        public String getId() {
+            return id;
+        }
+    }
+
+    @Test
+    public void testLinkStyles() {
+        LOG.info("Link styles");
+        FieldProcessor<TestClassG> instance = new FieldProcessor(TestClassG.class);
+        TestClassG testClass = new TestClassG("10");
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("widgets/10", testClass.relativePath);
+        assertEquals("/application/resources/widgets/10", testClass.absolutePath);
+        assertEquals("/application/resources/widgets/10", testClass.defaultStyle);
+        assertEquals("http://example.com/application/resources/widgets/10", testClass.absolute);
+    }
+
+    public static class TestClassH {
+
+        @InjectLink(TEMPLATE_B)
+        private String link;
+
+        public String getId() {
+            return "10";
+        }
+    }
+
+    @Test
+    public void testComputedProperty() {
+        LOG.info("Computed property");
+        FieldProcessor<TestClassH> instance = new FieldProcessor(TestClassH.class);
+        TestClassH testClass = new TestClassH();
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/widgets/10", testClass.link);
+    }
+
+    public static class TestClassI {
+
+        @InjectLink("widgets/${entity.id}")
+        private String link;
+
+        public String getId() {
+            return "10";
+        }
+    }
+
+    @Test
+    public void testEL() {
+        LOG.info("El link");
+        FieldProcessor<TestClassI> instance = new FieldProcessor(TestClassI.class);
+        TestClassI testClass = new TestClassI();
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/widgets/10", testClass.link);
+    }
+
+    public static class TestClassJ {
+
+        @InjectLink("widgets/${entity.id}/widget/{id}")
+        private String link;
+
+        public String getId() {
+            return "10";
+        }
+    }
+
+    @Test
+    public void testMixed() {
+        LOG.info("Mixed EL and template vars link");
+        FieldProcessor<TestClassJ> instance = new FieldProcessor(TestClassJ.class);
+        TestClassJ testClass = new TestClassJ();
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/widgets/10/widget/10", testClass.link);
+    }
+
+    public static class DependentInnerBean {
+
+        @InjectLink("${entity.id}")
+        public String outerUri;
+        @InjectLink("${instance.id}")
+        public String innerUri;
+
+        public String getId() {
+            return "inner";
+        }
+    }
+
+    public static class OuterBean {
+
+        public DependentInnerBean inner = new DependentInnerBean();
+
+        public String getId() {
+            return "outer";
+        }
+    }
+
+    @Test
+    public void testELScopes() {
+        LOG.info("EL scopes");
+        FieldProcessor<OuterBean> instance = new FieldProcessor(OuterBean.class);
+        OuterBean testClass = new OuterBean();
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/inner", testClass.inner.innerUri);
+        assertEquals("/application/resources/outer", testClass.inner.outerUri);
+    }
+
+    public static class BoundLinkBean {
+
+        @InjectLink(value = "{id}", bindings = {@Binding(name = "id", value = "${instance.name}")})
+        public String uri;
+
+        public String getName() {
+            return "name";
+        }
+    }
+
+    @Test
+    public void testELBinding() {
+        LOG.info("EL binding");
+        FieldProcessor<BoundLinkBean> instance = new FieldProcessor(BoundLinkBean.class);
+        BoundLinkBean testClass = new BoundLinkBean();
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/name", testClass.uri);
+    }
+
+    public static class BoundLinkOnLinkBean {
+
+        @InjectLink(value = "{id}",
+                bindings = {@Binding(name = "id", value = "${instance.name}")},
+                rel = "self")
+        public Link link;
+
+        public String getName() {
+            return "name";
+        }
+    }
+
+    @Test
+    public void testELBindingOnLink() {
+        LOG.info("EL binding");
+        FieldProcessor<BoundLinkOnLinkBean> instance = new FieldProcessor(BoundLinkOnLinkBean.class);
+        BoundLinkOnLinkBean testClass = new BoundLinkOnLinkBean();
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/name", testClass.link.getUri().toString());
+        assertEquals("self", testClass.link.getRel());
+    }
+
+    public static class BoundLinkOnLinksBean {
+
+        @InjectLinks({
+                @InjectLink(value = "{id}",
+                        bindings = {@Binding(name = "id", value = "${instance.name}")},
+                        rel = "self"),
+                @InjectLink(value = "{id}",
+                        bindings = {@Binding(name = "id", value = "${instance.name}")},
+                        rel = "other"),
+
+        })
+        public List<Link> links;
+
+        @InjectLinks({
+                @InjectLink(value = "{id}",
+                        bindings = {@Binding(name = "id", value = "${instance.name}")},
+                        rel = "self"),
+                @InjectLink(value = "{id}",
+                        bindings = {@Binding(name = "id", value = "${instance.name}")},
+                        rel = "other"),
+
+        })
+        public Link[] linksArray;
+
+        public String getName() {
+            return "name";
+        }
+    }
+
+    @Test
+    public void testELBindingOnLinks() {
+        LOG.info("EL binding");
+        FieldProcessor<BoundLinkOnLinksBean> instance = new FieldProcessor(BoundLinkOnLinksBean.class);
+        BoundLinkOnLinksBean testClass = new BoundLinkOnLinksBean();
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/name", testClass.links.get(0).getUri().toString());
+        assertEquals("self", testClass.links.get(0).getRel());
+        assertEquals("other", testClass.links.get(1).getRel());
+
+        assertEquals("/application/resources/name", testClass.linksArray[0].getUri().toString());
+        assertEquals("self", testClass.linksArray[0].getRel());
+        assertEquals("other", testClass.linksArray[1].getRel());
+
+    }
+
+    public static class ConditionalLinkBean {
+
+        @InjectLink(value = "{id}", condition = "${entity.uri1Enabled}")
+        public String uri1;
+
+        @InjectLink(value = "{id}", condition = "${entity.uri2Enabled}")
+        public String uri2;
+
+        public String getId() {
+            return "name";
+        }
+
+        public boolean isUri1Enabled() {
+            return true;
+        }
+
+        public boolean isUri2Enabled() {
+            return false;
+        }
+    }
+
+    @Test
+    public void testCondition() {
+        LOG.info("Condition");
+        FieldProcessor<ConditionalLinkBean> instance = new FieldProcessor(ConditionalLinkBean.class);
+        ConditionalLinkBean testClass = new ConditionalLinkBean();
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/name", testClass.uri1);
+        assertEquals(null, testClass.uri2);
+    }
+
+    @Path("a")
+    public static class SubResource {
+
+        @Path("b")
+        @GET
+        public String getB() {
+            return "hello world";
+        }
+    }
+
+    public static class SubResourceBean {
+
+        @InjectLink(resource = SubResource.class, method = "getB")
+        public String uri;
+    }
+
+    @Test
+    public void testSubresource() {
+        LOG.info("Subresource");
+        FieldProcessor<SubResourceBean> instance = new FieldProcessor(SubResourceBean.class);
+        SubResourceBean testClass = new SubResourceBean();
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/a/b", testClass.uri);
+    }
+
+    @Path("a")
+    public static class QueryResource {
+
+        @Path("b")
+        @GET
+        public String getB(@QueryParam("query") String query, @QueryParam("query2") String query2) {
+            return "hello world";
+        }
+    }
+
+    public static class QueryResourceBean {
+
+        public String getQueryParam() {
+            return queryExample;
+        }
+
+        private String queryExample;
+
+        public QueryResourceBean(String queryExample, String queryExample2) {
+            this.queryExample = queryExample;
+            this.queryExample2 = queryExample2;
+        }
+
+        public String getQueryParam2() {
+            return queryExample2;
+        }
+
+        private String queryExample2;
+
+        @InjectLink(resource = QueryResource.class, method = "getB",
+                bindings = {
+                        @Binding(name = "query", value = "${instance.queryParam}"),
+                        @Binding(name = "query2", value = "${instance.queryParam2}")
+                })
+        public String uri;
+    }
+
+    public static class QueryResourceBeanNoBindings {
+        //query parameters will be populated from uriInfo
+        //JERSEY-2863
+        @InjectLink(resource = QueryResource.class, method = "getB")
+        public String uri;
+    }
+
+    @Test
+    public void testQueryResource() {
+        LOG.info("QueryResource");
+        FieldProcessor<QueryResourceBean> instance = new FieldProcessor(QueryResourceBean.class);
+        QueryResourceBean testClass = new QueryResourceBean("queryExample", null);
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/a/b?query=queryExample&query2=", testClass.uri);
+    }
+
+    @Test
+    public void testDoubleQueryResource() {
+        LOG.info("QueryResource");
+        FieldProcessor<QueryResourceBean> instance = new FieldProcessor(QueryResourceBean.class);
+        QueryResourceBean testClass = new QueryResourceBean("queryExample", "queryExample2");
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/a/b?query=queryExample&query2=queryExample2", testClass.uri);
+    }
+
+    @Test
+    public void testQueryResourceWithoutBindings() {
+        LOG.info("QueryResource");
+        FieldProcessor<QueryResourceBeanNoBindings> instance = new FieldProcessor(QueryResourceBeanNoBindings.class);
+        QueryResourceBeanNoBindings testClass = new QueryResourceBeanNoBindings();
+        mockUriInfo.getQueryParameters().putSingle("query", "queryExample");
+        mockUriInfo.getQueryParameters().putSingle("query2", "queryExample2");
+        assertEquals("queryExample", mockUriInfo.getQueryParameters().getFirst("query"));
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/a/b?query=queryExample&query2=queryExample2", testClass.uri);
+        //clean mock
+        mockUriInfo.getQueryParameters().clear();
+    }
+
+    /** Bean param with method setter QueryParam. */
+    public static class BeanParamBeanA {
+        private String qparam;
+        @QueryParam("qparam")
+        public void setQParam(String qparam) {
+            this.qparam = qparam;
+        }
+    }
+
+    /** Bean param with field QueryParam. */
+    public static class BeanParamBeanB {
+        @QueryParam("query") public String query;
+    }
+
+    @Path("a")
+    public static class BeanParamQueryResource {
+
+        @Path("b")
+        @GET
+        public String getB(@BeanParam BeanParamBeanA beanParamBeanA, @BeanParam BeanParamBeanB beanParamBeanB) {
+            return "hello world";
+        }
+    }
+
+    public static class BeanParamResourceBean {
+
+        public String getQueryParam() {
+            return queryExample;
+        }
+
+        private String queryExample;
+
+        public BeanParamResourceBean(String queryExample) {
+            this.queryExample = queryExample;
+        }
+
+        @InjectLink(resource = BeanParamQueryResource.class, method = "getB",
+                bindings = {
+                        @Binding(name = "query", value = "${instance.queryParam}"),
+                        @Binding(name = "qparam", value = "foo")
+                })
+        public String uri;
+    }
+
+    @Test
+    public void testBeanParamResource() {
+        LOG.info("BeanParamResource");
+        FieldProcessor<BeanParamResourceBean> instance = new FieldProcessor(BeanParamResourceBean.class);
+        BeanParamResourceBean testClass = new BeanParamResourceBean("queryExample");
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("/application/resources/a/b?qparam=foo&query=queryExample", testClass.uri);
+    }
+
+    public static class TestClassK {
+
+        public static final ZipEntry zipEntry = new ZipEntry("entry");
+    }
+
+    public static class TestClassL {
+
+        public final ZipEntry zipEntry = new ZipEntry("entry");
+    }
+
+    private class LoggingFilter implements Filter {
+
+        private int count = 0;
+
+        @Override
+        public synchronized boolean isLoggable(LogRecord logRecord) {
+            if (logRecord.getThrown() instanceof IllegalAccessException) {
+                count++;
+                return false;
+            }
+            return true;
+        }
+
+        public int getCount() {
+            return count;
+        }
+    }
+
+    @Test
+    public void testKL() {
+        final LoggingFilter lf = new LoggingFilter();
+
+        Logger.getLogger(FieldDescriptor.class.getName()).setFilter(lf);
+        assertTrue(lf.getCount() == 0);
+
+        FieldProcessor<TestClassK> instanceK = new FieldProcessor(TestClassK.class);
+        TestClassK testClassK = new TestClassK();
+        instanceK.processLinks(testClassK, mockUriInfo, mockRmc, mockRlcc);
+
+        assertTrue(lf.getCount() == 0);
+
+        FieldProcessor<TestClassL> instanceL = new FieldProcessor(TestClassL.class);
+        TestClassL testClassL = new TestClassL();
+        instanceL.processLinks(testClassL, mockUriInfo, mockRmc, mockRlcc);
+
+        assertTrue(lf.getCount() == 0);
+
+        Logger.getLogger(FieldDescriptor.class.getName()).setFilter(null);
+
+    }
+
+    public static class TestClassM {
+
+        @InjectLink(value = TEMPLATE_B, style = InjectLink.Style.RELATIVE_PATH)
+        private String thelink;
+
+        private String id;
+
+        @InjectLinkNoFollow
+        private TestClassE nested;
+
+        @XmlTransient
+        private TestClassE transientNested;
+
+        public TestClassM(String id, TestClassE e, TestClassE transientNested) {
+            this.id = id;
+            this.nested = e;
+            this.transientNested = transientNested;
+        }
+
+        public String getId() {
+            return id;
+        }
+    }
+
+    @Test
+    public void testNoRecursiveNesting() {
+        LOG.info("No Recursive Nesting");
+        FieldProcessor<TestClassM> instance = new FieldProcessor(TestClassM.class);
+        TestClassE nested = new TestClassE("10");
+        TestClassE transientNested = new TestClassE("30");
+        TestClassM testClass = new TestClassM("20", nested, transientNested);
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+        assertEquals("widgets/20", testClass.thelink);
+        assertEquals(null, testClass.nested.link);
+        assertEquals(null, testClass.transientNested.link);
+    }
+
+    public static class TestClassN {
+        // Simulate object injected by JPA
+        // in order to test a fix for JERSEY-2625
+        private transient Iterable res1 = new Iterable() {
+            @Override
+            public Iterator iterator() {
+                throw new RuntimeException("Declarative linking feature is incorrectly processing a transient iterator");
+            }
+
+        };
+    }
+
+    @Test
+    public void testIgnoreTransient() {
+        TestClassN testClass = new TestClassN();
+        FieldProcessor<TestClassN> instance = new FieldProcessor(TestClassN.class);
+        instance.processLinks(testClass, mockUriInfo, mockRmc, mockRlcc);
+    }
+
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/HeaderProcessorTest.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/HeaderProcessorTest.java
new file mode 100644
index 0000000..cf360ab
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/HeaderProcessorTest.java
@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.MatchResult;
+
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.PathSegment;
+import javax.ws.rs.core.UriBuilder;
+
+import org.glassfish.jersey.internal.util.collection.MultivaluedStringMap;
+import org.glassfish.jersey.linking.InjectLink.Extension;
+import org.glassfish.jersey.linking.mapping.ResourceMappingContext;
+import org.glassfish.jersey.server.ExtendedUriInfo;
+import org.glassfish.jersey.server.model.Resource;
+import org.glassfish.jersey.server.model.ResourceMethod;
+import org.glassfish.jersey.server.model.RuntimeResource;
+import org.glassfish.jersey.uri.UriTemplate;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ *
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+public class HeaderProcessorTest {
+
+    ExtendedUriInfo mockUriInfo = new ExtendedUriInfo() {
+
+        private static final String baseURI = "http://example.com/application/resources";
+
+        public String getPath() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        public String getPath(boolean decode) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        public List<PathSegment> getPathSegments() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        public List<PathSegment> getPathSegments(boolean decode) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        public URI getRequestUri() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        public UriBuilder getRequestUriBuilder() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        public URI getAbsolutePath() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        public UriBuilder getAbsolutePathBuilder() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        public URI getBaseUri() {
+            return getBaseUriBuilder().build();
+        }
+
+        public UriBuilder getBaseUriBuilder() {
+            return UriBuilder.fromUri(baseURI);
+        }
+
+        public MultivaluedMap<String, String> getPathParameters() {
+            return new MultivaluedStringMap();
+        }
+
+        public MultivaluedMap<String, String> getPathParameters(boolean decode) {
+            return new MultivaluedStringMap();
+        }
+
+        public MultivaluedMap<String, String> getQueryParameters() {
+            return new MultivaluedStringMap();
+        }
+
+        public MultivaluedMap<String, String> getQueryParameters(boolean decode) {
+            return new MultivaluedStringMap();
+        }
+
+        public List<String> getMatchedURIs() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        public List<String> getMatchedURIs(boolean decode) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        public List<Object> getMatchedResources() {
+            Object dummyResource = new Object() {};
+            return Collections.singletonList(dummyResource);
+        }
+
+        @Override
+        public URI resolve(URI uri) {
+            throw new UnsupportedOperationException(
+                    "Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public URI relativize(URI uri) {
+            throw new UnsupportedOperationException(
+                    "Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Throwable getMappedThrowable() {
+            throw new UnsupportedOperationException(
+                    "Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public List<MatchResult> getMatchedResults() {
+            throw new UnsupportedOperationException(
+                    "Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public List<UriTemplate> getMatchedTemplates() {
+            throw new UnsupportedOperationException(
+                    "Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public List<PathSegment> getPathSegments(String name) {
+            throw new UnsupportedOperationException(
+                    "Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public List<PathSegment> getPathSegments(String name, boolean decode) {
+            throw new UnsupportedOperationException(
+                    "Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public List<RuntimeResource> getMatchedRuntimeResources() {
+            throw new UnsupportedOperationException(
+                    "Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public ResourceMethod getMatchedResourceMethod() {
+            throw new UnsupportedOperationException(
+                    "Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Resource getMatchedModelResource() {
+            throw new UnsupportedOperationException(
+                    "Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public List<ResourceMethod> getMatchedResourceLocators() {
+            throw new UnsupportedOperationException(
+                    "Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public List<Resource> getLocatorSubResources() {
+            throw new UnsupportedOperationException(
+                    "Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+    };
+
+    ResourceMappingContext mockRmc = new ResourceMappingContext() {
+
+        @Override
+        public ResourceMappingContext.Mapping getMapping(Class<?> resource) {
+            return null;
+        }
+    };
+
+    @InjectLink(value = "A")
+    public static class EntityA {
+    }
+
+    @Test
+    public void testLiteral() {
+        System.out.println("Literal");
+        HeaderProcessor<EntityA> instance = new HeaderProcessor(EntityA.class);
+        EntityA testClass = new EntityA();
+        List<String> headerValues = instance.getLinkHeaderValues(testClass, mockUriInfo, mockRmc);
+        assertEquals(1, headerValues.size());
+        String headerValue = headerValues.get(0);
+        assertEquals("</application/resources/A>", headerValue);
+    }
+
+    @InjectLink(value = "${entity.id}")
+    public static class EntityB {
+
+        public String getId() {
+            return "B";
+        }
+    }
+
+    @Test
+    public void testEL() {
+        System.out.println("EL");
+        HeaderProcessor<EntityB> instance = new HeaderProcessor(EntityB.class);
+        EntityB testClass = new EntityB();
+        List<String> headerValues = instance.getLinkHeaderValues(testClass, mockUriInfo, mockRmc);
+        assertEquals(1, headerValues.size());
+        String headerValue = headerValues.get(0);
+        assertEquals("</application/resources/B>", headerValue);
+    }
+
+    @InjectLink(value = "{id}")
+    public static class EntityC {
+
+        public String getId() {
+            return "C";
+        }
+    }
+
+    @Test
+    public void testTemplateLiteral() {
+        System.out.println("Template Literal");
+        HeaderProcessor<EntityC> instance = new HeaderProcessor(EntityC.class);
+        EntityC testClass = new EntityC();
+        List<String> headerValues = instance.getLinkHeaderValues(testClass, mockUriInfo, mockRmc);
+        assertEquals(1, headerValues.size());
+        String headerValue = headerValues.get(0);
+        assertEquals("</application/resources/C>", headerValue);
+    }
+
+    @InjectLinks({
+            @InjectLink(value = "A"),
+            @InjectLink(value = "B")
+    })
+    public static class EntityD {
+    }
+
+    @Test
+    public void testMultiple() {
+        System.out.println("Multiple Literal");
+        HeaderProcessor<EntityD> instance = new HeaderProcessor(EntityD.class);
+        EntityD testClass = new EntityD();
+        List<String> headerValues = instance.getLinkHeaderValues(testClass, mockUriInfo, mockRmc);
+        assertEquals(2, headerValues.size());
+        // not sure if annotation order is supposed to be preserved but it seems
+        // to work as expected
+        String headerValue = headerValues.get(0);
+        assertEquals("</application/resources/A>", headerValue);
+        headerValue = headerValues.get(1);
+        assertEquals("</application/resources/B>", headerValue);
+    }
+
+    @InjectLink(value = "E",
+            rel = "relE",
+            rev = "revE",
+            type = "type/e",
+            title = "titleE",
+            anchor = "anchorE",
+            media = "mediaE",
+            hreflang = "en-E",
+            extensions = {
+                    @Extension(name = "e1", value = "v1"),
+                    @Extension(name = "e2", value = "v2")
+            }
+    )
+    public static class EntityE {
+    }
+
+    @Test
+    public void testParameters() {
+        System.out.println("Parameters");
+        HeaderProcessor<EntityE> instance = new HeaderProcessor(EntityE.class);
+        EntityE testClass = new EntityE();
+        List<String> headerValues = instance.getLinkHeaderValues(testClass, mockUriInfo, mockRmc);
+        assertEquals(1, headerValues.size());
+        String headerValue = headerValues.get(0);
+        assertTrue(headerValue.contains("</application/resources/E>"));
+        assertTrue(headerValue.contains("; rel=\"relE\""));
+        assertTrue(headerValue.contains("; rev=\"revE\""));
+        assertTrue(headerValue.contains("; type=\"type/e\""));
+        assertTrue(headerValue.contains("; title=\"titleE\""));
+        assertTrue(headerValue.contains("; anchor=\"anchorE\""));
+        assertTrue(headerValue.contains("; media=\"mediaE\""));
+        assertTrue(headerValue.contains("; hreflang=\"en-E\""));
+        assertTrue(headerValue.contains("; e1=\"v1\""));
+        assertTrue(headerValue.contains("; e2=\"v2\""));
+    }
+
+    @InjectLinks({
+            @InjectLink(value = "${entity.id1}", condition = "${entity.id1Enabled}"),
+            @InjectLink(value = "${entity.id2}", condition = "${entity.id2Enabled}")
+    })
+    public static class EntityF {
+
+        public boolean isId1Enabled() {
+            return true;
+        }
+
+        public String getId1() {
+            return "1";
+        }
+
+        public boolean isId2Enabled() {
+            return false;
+        }
+
+        public String getId2() {
+            return "2";
+        }
+    }
+
+    @Test
+    public void testConditional() {
+        System.out.println("EL");
+        HeaderProcessor<EntityF> instance = new HeaderProcessor(EntityF.class);
+        EntityF testClass = new EntityF();
+        List<String> headerValues = instance.getLinkHeaderValues(testClass, mockUriInfo, mockRmc);
+        assertEquals(1, headerValues.size());
+        String headerValue = headerValues.get(0);
+        assertEquals("</application/resources/1>", headerValue);
+    }
+
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/LinkELContextTest.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/LinkELContextTest.java
new file mode 100644
index 0000000..89bf3f4
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/LinkELContextTest.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking;
+
+import javax.el.ExpressionFactory;
+import javax.el.ValueExpression;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+/**
+ *
+ * @author Mark Hadley
+ * @author Gerard Davison (gerard.davison at oracle.com)
+ */
+public class LinkELContextTest {
+
+    @Test
+    public void testExpressionFactory() {
+        System.out.println("Create expression factory");
+        ExpressionFactory factory = ExpressionFactory.newInstance();
+        assertNotNull(factory);
+    }
+
+    @Test
+    public void testLiteralExpression() {
+        System.out.println("Literal expression");
+        ExpressionFactory factory = ExpressionFactory.newInstance();
+        LinkELContext context = new LinkELContext(new BooleanBean(), null);
+        ValueExpression expr = factory.createValueExpression(context,
+                "${1+2}", int.class);
+        Object value = expr.getValue(context);
+        assertEquals(3, value);
+    }
+
+    public static final String ID = "10";
+    public static final String NAME = "TheName";
+
+    public static class EntityBean {
+
+        private String id = ID;
+        private String name = NAME;
+
+        public String getId() {
+            return id;
+        }
+
+        public String getName() {
+            return name;
+        }
+    }
+
+    @Test
+    public void testExpression() {
+        System.out.println("Raw expression");
+        ExpressionFactory factory = ExpressionFactory.newInstance();
+        LinkELContext context = new LinkELContext(new EntityBean(), null);
+        ValueExpression expr = factory.createValueExpression(context,
+                "${entity.id}", String.class);
+        Object value = expr.getValue(context);
+        assertEquals(ID, value);
+    }
+
+    @Test
+    public void testEmbeddedExpression() {
+        System.out.println("Embedded expression");
+        ExpressionFactory factory = ExpressionFactory.newInstance();
+        LinkELContext context = new LinkELContext(new EntityBean(), null);
+        ValueExpression expr = factory.createValueExpression(context,
+                "foo/${entity.id}/bar", String.class);
+        Object value = expr.getValue(context);
+        assertEquals("foo/" + ID + "/bar", value);
+    }
+
+    @Test
+    public void testMultipleExpressions() {
+        System.out.println("Multiple expressions");
+        ExpressionFactory factory = ExpressionFactory.newInstance();
+        LinkELContext context = new LinkELContext(new EntityBean(), null);
+        ValueExpression expr = factory.createValueExpression(context,
+                "foo/${entity.id}/bar/${entity.name}", String.class);
+        Object value = expr.getValue(context);
+        assertEquals("foo/" + ID + "/bar/" + NAME, value);
+    }
+
+    public static class OuterEntityBean {
+
+        private EntityBean inner = new EntityBean();
+
+        public EntityBean getInner() {
+            return inner;
+        }
+    }
+
+    @Test
+    public void testNestedExpression() {
+        System.out.println("Nested expression");
+        ExpressionFactory factory = ExpressionFactory.newInstance();
+        LinkELContext context = new LinkELContext(new OuterEntityBean(), null);
+        ValueExpression expr = factory.createValueExpression(context,
+                "${entity.inner.id}", String.class);
+        Object value = expr.getValue(context);
+        assertEquals(ID, value);
+    }
+
+    public static class BooleanBean {
+
+        public boolean getEnabled() {
+            return true;
+        }
+
+        public boolean getValue(boolean value) {
+            return value;
+        }
+    }
+
+    @Test
+    public void testBooleanExpression() {
+        System.out.println("Boolean expression");
+        ExpressionFactory factory = ExpressionFactory.newInstance();
+        LinkELContext context = new LinkELContext(new BooleanBean(), null);
+        ValueExpression expr = factory.createValueExpression(context,
+                "${entity.enabled}", boolean.class);
+        Object value = expr.getValue(context);
+        assertEquals(true, value);
+        expr = factory.createValueExpression(context,
+                "${entity.getValue(true)}", boolean.class);
+        value = expr.getValue(context);
+        assertEquals(true, value);
+        expr = factory.createValueExpression(context,
+                "${entity.getValue(false)}", boolean.class);
+        value = expr.getValue(context);
+        assertEquals(false, value);
+    }
+
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/LinkingManualTest.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/LinkingManualTest.java
new file mode 100644
index 0000000..6375042
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/LinkingManualTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration;
+
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+
+import org.glassfish.jersey.client.ClientConfig;
+import org.glassfish.jersey.linking.integration.app.LinkingManualApplication;
+import org.glassfish.jersey.linking.integration.representations.OrderRequest;
+import org.glassfish.jersey.test.JerseyTest;
+import org.junit.Test;
+import org.skyscreamer.jsonassert.JSONAssert;
+
+public class LinkingManualTest extends JerseyTest {
+
+    @Override
+    protected Application configure() {
+        return new LinkingManualApplication();
+    }
+
+    @Override
+    protected void configureClient(ClientConfig config) {
+
+    }
+
+    @Test
+    public void orderContainsManualLink() throws Exception {
+        OrderRequest request = new OrderRequest();
+        request.setDrink("Coffee");
+        Response response = target().path("/orders").request()
+                .post(Entity.entity(request, MediaType.APPLICATION_JSON_TYPE));
+
+        String order = response.readEntity(String.class);
+        JSONAssert.assertEquals("{id:'123',price:'1.99',links:["
+                        + "{uri:'/',params:{rel:'root'},uriBuilder:{absolute:false},rel:'root',rels:['root']}"
+                        + "]}",
+                order, true);
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/LinkingTest.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/LinkingTest.java
new file mode 100644
index 0000000..d125faf
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/LinkingTest.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration;
+
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+
+import org.glassfish.jersey.client.ClientConfig;
+import org.glassfish.jersey.linking.integration.app.LinkingApplication;
+import org.glassfish.jersey.linking.integration.representations.OrderRequest;
+import org.glassfish.jersey.test.JerseyTest;
+import org.junit.Test;
+import org.skyscreamer.jsonassert.JSONAssert;
+
+public class LinkingTest extends JerseyTest {
+
+    @Override
+    protected Application configure() {
+        return new LinkingApplication();
+    }
+
+    @Override
+    protected void configureClient(ClientConfig config) {
+
+    }
+
+    @Test
+    public void orderContainsProvidedLinks() throws Exception {
+        OrderRequest request = new OrderRequest();
+        request.setDrink("Coffee");
+        Response response = target().path("/orders").request()
+                .post(Entity.entity(request, MediaType.APPLICATION_JSON_TYPE));
+
+        String order = response.readEntity(String.class);
+        JSONAssert.assertEquals("{id:'123',price:'1.99',links:["
+                    + "{uri:'/orders/123',params:{rel:'self'},uriBuilder:{absolute:false},rel:'self',rels:['self']},"
+                    + "{uri:'/payments/order/123',params:{rel:'pay'},uriBuilder:{absolute:false},rel:'pay',rels:['pay']},"
+                    + "{uri:'/',params:{rel:'root'},uriBuilder:{absolute:false},rel:'root',rels:['root']}"
+                    + "]}",
+                order, true);
+    }
+
+    @Test
+    public void providedLinksSupportConditions() throws Exception {
+        OrderRequest request = new OrderRequest();
+        request.setDrink("Water");
+        Response response = target().path("/orders").request()
+                .post(Entity.entity(request, MediaType.APPLICATION_JSON_TYPE));
+
+        String order = response.readEntity(String.class);
+        JSONAssert.assertEquals("{id:'123',price:'0.0',links:["
+                    + "{uri:'/orders/123',params:{rel:'self'},uriBuilder:{absolute:false},rel:'self',rels:['self']},"
+                    + "{uri:'/',params:{rel:'root'},uriBuilder:{absolute:false},rel:'root',rels:['root']}"
+                    + "]}",
+                order, true);
+    }
+
+    @Test
+    public void metaAnnotationsCanBeUsedToAbstractCommonBehavior_1() throws Exception {
+        Response response = target().path("/orders").request()
+                .get();
+
+        String order = response.readEntity(String.class);
+        JSONAssert.assertEquals("{number:0,size:2,totalPages:3,numberOfElements:0,totalElements:6,links:["
+                    + "{uri:'/orders',params:{rel:'create'},uriBuilder:{absolute:false},rels:['create'],rel:'create'},"
+                    + "{uri:'/orders?page=1&size=2',params:{rel:'next'},uriBuilder:{absolute:false},rels:['next'],rel:'next'}"
+                    + "],orders:["
+                    + "{id:'1',price:'1.99',links:["
+                    + "{uri:'/orders/1',params:{rel:'self'},uriBuilder:{absolute:false},rels:['self'],rel:'self'},"
+                    + "{uri:'/payments/order/1',params:{rel:'pay'},uriBuilder:{absolute:false},rels:['pay'],rel:'pay'}]},"
+                    + "{id:'2',price:'0.0',links:["
+                    + "{uri:'/orders/2',params:{rel:'self'},uriBuilder:{absolute:false},rels:['self'],rel:'self'}]}"
+                    + "],firstPage:true,previousPageAvailable:false,nextPageAvailable:true,lastPage:false}",
+                order, true);
+    }
+
+    @Test
+    public void metaAnnotationsCanBeUsedToAbstractCommonBehavior_2() throws Exception {
+        Response response = target().path("/orders").queryParam("page", "1").request()
+                .get();
+
+        String order = response.readEntity(String.class);
+        JSONAssert.assertEquals("{number:1,size:2,totalPages:3,numberOfElements:0,totalElements:6,links:["
+                    + "{uri:'/orders',params:{rel:'create'},uriBuilder:{absolute:false},rels:['create'],rel:'create'},"
+                    + "{uri:'/orders?page=2&size=2',params:{rel:'next'},uriBuilder:{absolute:false},rels:['next'],rel:'next'},"
+                    + "{uri:'/orders?page=0&size=2',params:{rel:'prev'},uriBuilder:{absolute:false},rels:['prev'],rel:'prev'}"
+                    + "],orders:["
+                    + "{id:'3',price:'1.99',links:["
+                    + "{uri:'/orders/3',params:{rel:'self'},uriBuilder:{absolute:false},rels:['self'],rel:'self'},"
+                    + "{uri:'/payments/order/3',params:{rel:'pay'},uriBuilder:{absolute:false},rels:['pay'],rel:'pay'}]},"
+                    + "{id:'4',price:'0.0',links:["
+                    + "{uri:'/orders/4',params:{rel:'self'},uriBuilder:{absolute:false},rels:['self'],rel:'self'}]}"
+                    + "],firstPage:false,previousPageAvailable:true,nextPageAvailable:true,lastPage:false}",
+                order, true);
+    }
+
+    @Test
+    public void metaAnnotationsCanBeUsedToAbstractCommonBehavior_3() throws Exception {
+        Response response = target().path("/orders").queryParam("page", "2").request()
+                .get();
+
+        String order = response.readEntity(String.class);
+        JSONAssert.assertEquals("{number:2,size:2,totalPages:3,numberOfElements:0,totalElements:6,links:["
+                    + "{uri:'/orders',params:{rel:'create'},uriBuilder:{absolute:false},rels:['create'],rel:'create'},"
+                    + "{uri:'/orders?page=1&size=2',params:{rel:'prev'},uriBuilder:{absolute:false},rels:['prev'],rel:'prev'}"
+                    + "],orders:["
+                    + "{id:'5',price:'1.99',links:["
+                    + "{uri:'/orders/5',params:{rel:'self'},uriBuilder:{absolute:false},rels:['self'],rel:'self'},"
+                    + "{uri:'/payments/order/5',params:{rel:'pay'},uriBuilder:{absolute:false},rels:['pay'],rel:'pay'}]},"
+                    + "{id:'6',price:'0.0',links:["
+                    + "{uri:'/orders/6',params:{rel:'self'},uriBuilder:{absolute:false},rels:['self'],rel:'self'}]}"
+                    + "],firstPage:false,previousPageAvailable:true,nextPageAvailable:false,lastPage:true}",
+                order, true);
+    }
+
+
+    @Test
+    public void provideCanBeUsedInConjunctionWithInject() throws Exception {
+        Response response = target().path("/payments/p-1").request().get();
+        String order = response.readEntity(String.class);
+        JSONAssert.assertEquals("{id:'p-1',orderId:'1',links:["
+                    + "{uri:'/payments/p-1',params:{rel:'self'},uriBuilder:{absolute:false},rel:'self',rels:['self']},"
+                    + "{uri:'/orders/1',params:{rel:'order'},uriBuilder:{absolute:false},rel:'order',rels:['order']}]}",
+                order, true);
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/LinkingApplication.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/LinkingApplication.java
new file mode 100644
index 0000000..dc010c2
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/LinkingApplication.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.app;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.glassfish.jersey.linking.DeclarativeLinkingFeature;
+
+public class LinkingApplication extends LinkingManualApplication {
+
+    private static final Set<Object> singletons = new HashSet<>(Arrays.asList(
+            new DeclarativeLinkingFeature(),
+            new ObjectMapperContextResolver()));
+
+    @Override
+    public Set<Object> getSingletons() {
+        return singletons;
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/LinkingManualApplication.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/LinkingManualApplication.java
new file mode 100644
index 0000000..b5a498a
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/LinkingManualApplication.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.app;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import javax.ws.rs.core.Application;
+
+public class LinkingManualApplication extends Application {
+
+    private static final Set<Class<?>> classes = new HashSet<>(Arrays.asList(OrdersResource.class, PaymentResource.class));
+
+    @Override
+    public Set<Class<?>> getClasses() {
+        return classes;
+    }
+
+    @Override
+    public Set<Object> getSingletons() {
+        return Collections.singleton(new ObjectMapperContextResolver());
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/ObjectMapperContextResolver.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/ObjectMapperContextResolver.java
new file mode 100644
index 0000000..d12e369
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/ObjectMapperContextResolver.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.app;
+
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.ext.ContextResolver;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class ObjectMapperContextResolver implements ContextResolver<ObjectMapper> {
+    @Context
+    private HttpHeaders headers;
+
+    private final ObjectMapper mapper;
+
+    public ObjectMapperContextResolver() {
+        mapper = new ObjectMapper();
+
+        // serialization behaviour
+        mapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
+    }
+
+    @Override
+    public ObjectMapper getContext(Class<?> type) {
+        return mapper;
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/OrdersResource.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/OrdersResource.java
new file mode 100644
index 0000000..27d559d
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/OrdersResource.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.app;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.DefaultValue;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.Link;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+
+import org.glassfish.jersey.linking.Binding;
+import org.glassfish.jersey.linking.ProvideLink;
+import org.glassfish.jersey.linking.integration.representations.ExtendedOrder;
+import org.glassfish.jersey.linking.integration.representations.Order;
+import org.glassfish.jersey.linking.integration.representations.OrderPage;
+import org.glassfish.jersey.linking.integration.representations.OrderRequest;
+import org.glassfish.jersey.linking.integration.representations.PageLinks;
+import org.glassfish.jersey.linking.integration.representations.PaymentConfirmation;
+
+
+@Path("/orders")
+public class OrdersResource {
+
+    @Context
+    private UriInfo uriInfo;
+
+
+    @ProvideLink(value = OrderPage.class, rel = "create")
+    @Consumes(MediaType.APPLICATION_JSON)
+    @Produces(MediaType.APPLICATION_JSON)
+    @POST
+    public Response create(OrderRequest request) {
+        Order order = new Order();
+        order.setId("123");
+        if ("water".equalsIgnoreCase(request.getDrink())) {
+            order.setPrice("0.0");
+        } else {
+            order.setPrice("1.99");
+        }
+
+        order.getLinks().add(Link.fromUri("/").rel("root").build());
+        return Response.ok(order).build();
+    }
+
+    @ProvideLink(value = Order.class, rel = "self", bindings = @Binding(name = "orderId", value = "${instance.id}"))
+    @ProvideLink(value = PaymentConfirmation.class, rel = "order",
+                 bindings = @Binding(name = "orderId", value = "${instance.orderId}"))
+    @Produces(MediaType.APPLICATION_JSON)
+    @GET
+    @Path("/{orderId}")
+    public Response get(@PathParam("orderId") String orderId) {
+        ExtendedOrder order = new ExtendedOrder();
+        order.setId("123");
+        order.setPrice("1.99");
+        return Response.ok(order).build();
+    }
+
+
+    @ProvideLink(value = ExtendedOrder.class, rel = "delete",
+                 bindings = @Binding(name = "orderId", value = "${instance.id}"))
+    @DELETE
+    @Path("/{orderId}")
+    public Response delete(@PathParam("orderId") String orderId) {
+        return Response.noContent().build();
+    }
+
+
+    @PageLinks(OrderPage.class)
+    @Produces(MediaType.APPLICATION_JSON)
+    @GET
+    public Response list(@QueryParam("page") @DefaultValue("0") int page, @QueryParam("size") @DefaultValue("2")  int size) {
+        OrderPage orderPage = new OrderPage();
+
+        orderPage.setFirstPage(page == 0);
+        orderPage.setLastPage(page == 2);
+        orderPage.setPreviousPageAvailable(page > 0);
+        orderPage.setNextPageAvailable(page < 2);
+        orderPage.setNumber(page);
+        orderPage.setSize(size);
+        orderPage.setTotalElements(6);
+        orderPage.setTotalPages(3);
+
+        orderPage.setOrders(generateOrders(page, size));
+
+        return Response.ok(orderPage).build();
+    }
+
+    private List<Order> generateOrders(int page, int size) {
+        final int base = page * size;
+        return IntStream.range(1, size + 1).map(x -> x + base).mapToObj(id -> {
+            Order order = new Order();
+            order.setId(Integer.toString(id));
+            order.setPrice(((id & 1) == 1) ? "1.99" : "0.0");
+            return order;
+        }).collect(Collectors.toList());
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/PaymentResource.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/PaymentResource.java
new file mode 100644
index 0000000..a8d33a5
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/app/PaymentResource.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.app;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.GET;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+
+import org.glassfish.jersey.linking.Binding;
+import org.glassfish.jersey.linking.ProvideLink;
+import org.glassfish.jersey.linking.integration.representations.Order;
+import org.glassfish.jersey.linking.integration.representations.PaymentConfirmation;
+import org.glassfish.jersey.linking.integration.representations.PaymentDetails;
+
+
+@Path("/payments")
+public class PaymentResource {
+
+
+    @ProvideLink(value = Order.class, rel = "pay", bindings = {
+            @Binding(name = "orderId", value = "${instance.id}")}, condition = "${instance.price != '0.0'}")
+    @Produces(MediaType.APPLICATION_JSON)
+    @Consumes(MediaType.APPLICATION_JSON)
+    @PUT
+    @Path("/order/{orderId}")
+    public Response pay(@PathParam("orderId") String orderId, PaymentDetails paymentDetails) {
+        PaymentConfirmation paymentConfirmation = new PaymentConfirmation();
+        paymentConfirmation.setOrderId(orderId);
+        paymentConfirmation.setId("p-" + orderId);
+        return Response.ok(paymentConfirmation).build();
+    }
+
+    @Produces(MediaType.APPLICATION_JSON)
+    @GET
+    @Path("{id}")
+    public Response getConfirmation(@PathParam("id") String id) {
+        PaymentConfirmation paymentConfirmation = new PaymentConfirmation();
+        paymentConfirmation.setId(id);
+        paymentConfirmation.setOrderId(id.substring(2));
+        return Response.ok(paymentConfirmation).build();
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/ExtendedOrder.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/ExtendedOrder.java
new file mode 100644
index 0000000..934f18f
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/ExtendedOrder.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.representations;
+
+public class ExtendedOrder extends Order {
+
+    private String details;
+
+    public String getDetails() {
+        return details;
+    }
+
+    public void setDetails(String details) {
+        this.details = details;
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/Order.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/Order.java
new file mode 100644
index 0000000..4daf27d
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/Order.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.representations;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.ws.rs.core.Link;
+
+import org.glassfish.jersey.linking.InjectLinks;
+
+public class Order {
+
+    private String id;
+
+    private String drink;
+
+    private String price;
+
+    @InjectLinks
+    private List<Link> links = new ArrayList<>();
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getDrink() {
+        return drink;
+    }
+
+    public void setDrink(String drink) {
+        this.drink = drink;
+    }
+
+    public String getPrice() {
+        return price;
+    }
+
+    public void setPrice(String price) {
+        this.price = price;
+    }
+
+    public List<Link> getLinks() {
+        return links;
+    }
+
+    public void setLinks(List<Link> links) {
+        this.links = links;
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/OrderPage.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/OrderPage.java
new file mode 100644
index 0000000..3aef37c
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/OrderPage.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.representations;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class OrderPage extends Page {
+
+    private List<Order> orders = new ArrayList<>();
+
+    public List<Order> getOrders() {
+        return orders;
+    }
+
+    public void setOrders(List<Order> orders) {
+        this.orders = orders;
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/OrderRequest.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/OrderRequest.java
new file mode 100644
index 0000000..4af0a9d
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/OrderRequest.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.representations;
+
+public class OrderRequest {
+    private String drink;
+
+    public String getDrink() {
+        return drink;
+    }
+
+    public void setDrink(String drink) {
+        this.drink = drink;
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/Page.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/Page.java
new file mode 100644
index 0000000..8e1f1ba
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/Page.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.representations;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.ws.rs.core.Link;
+
+import org.glassfish.jersey.linking.InjectLinks;
+
+public class Page {
+
+    /**
+     * The number of the current page. Is always non-negative and less that {@code Page#getTotalPages()}.
+     */
+    private int number;
+
+    /**
+     * The size of the page.
+     */
+    private int size;
+
+    /**
+     * The number of total pages.
+     */
+    private int totalPages;
+
+    /**
+     * The number of elements currently on this page.
+     */
+    private int numberOfElements;
+
+    /**
+     * The total amount of elements.
+     */
+    private long totalElements;
+
+    /**
+     * If there is a previous page.
+     */
+    private boolean isPreviousPageAvailable;
+
+    /**
+     * Whether the current page is the first one.
+     */
+    private boolean isFirstPage;
+
+    /**
+     * If there is a next page.
+     */
+    private boolean isNextPageAvailable;
+
+    /**
+     * Whether the current page is the last one.
+     */
+    private boolean isLastPage;
+
+    @InjectLinks
+    private List<Link> links = new ArrayList<>();
+
+    public int getNumber() {
+        return number;
+    }
+
+    public void setNumber(int number) {
+        this.number = number;
+    }
+
+    public int getSize() {
+        return size;
+    }
+
+    public void setSize(int size) {
+        this.size = size;
+    }
+
+    public int getTotalPages() {
+        return totalPages;
+    }
+
+    public void setTotalPages(int totalPages) {
+        this.totalPages = totalPages;
+    }
+
+    public int getNumberOfElements() {
+        return numberOfElements;
+    }
+
+    public void setNumberOfElements(int numberOfElements) {
+        this.numberOfElements = numberOfElements;
+    }
+
+    public long getTotalElements() {
+        return totalElements;
+    }
+
+    public void setTotalElements(long totalElements) {
+        this.totalElements = totalElements;
+    }
+
+    public boolean isPreviousPageAvailable() {
+        return isPreviousPageAvailable;
+    }
+
+    public void setPreviousPageAvailable(boolean previousPageAvailable) {
+        isPreviousPageAvailable = previousPageAvailable;
+    }
+
+    public boolean isFirstPage() {
+        return isFirstPage;
+    }
+
+    public void setFirstPage(boolean firstPage) {
+        isFirstPage = firstPage;
+    }
+
+    public boolean isNextPageAvailable() {
+        return isNextPageAvailable;
+    }
+
+    public void setNextPageAvailable(boolean nextPageAvailable) {
+        isNextPageAvailable = nextPageAvailable;
+    }
+
+    public boolean isLastPage() {
+        return isLastPage;
+    }
+
+    public void setLastPage(boolean lastPage) {
+        isLastPage = lastPage;
+    }
+
+    public List<Link> getLinks() {
+        return links;
+    }
+
+    public void setLinks(List<Link> links) {
+        this.links = links;
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/PageLinks.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/PageLinks.java
new file mode 100644
index 0000000..421ba52
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/PageLinks.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.representations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.glassfish.jersey.linking.Binding;
+import org.glassfish.jersey.linking.ProvideLink;
+
+@ProvideLink(value = ProvideLink.InheritFromAnnotation.class, rel = "next", bindings = {
+        @Binding(name = "page", value = "${instance.number + 1}"),
+        @Binding(name = "size", value = "${instance.size}"),
+}, condition = "${instance.nextPageAvailable}")
+@ProvideLink(value = ProvideLink.InheritFromAnnotation.class, rel = "prev", bindings = {
+        @Binding(name = "page", value = "${instance.number - 1}"),
+        @Binding(name = "size", value = "${instance.size}"),
+}, condition = "${instance.previousPageAvailable}")
+@Target({ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface PageLinks {
+    Class<?> value();
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/PaymentConfirmation.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/PaymentConfirmation.java
new file mode 100644
index 0000000..869dd90
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/PaymentConfirmation.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.representations;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.ws.rs.core.Link;
+
+import org.glassfish.jersey.linking.InjectLink;
+import org.glassfish.jersey.linking.InjectLinks;
+import org.glassfish.jersey.linking.integration.app.PaymentResource;
+
+public class PaymentConfirmation {
+
+    private String id;
+
+    private String orderId;
+
+    @InjectLinks(
+            @InjectLink(resource = PaymentResource.class, method = "getConfirmation", rel = "self")
+    )
+    private List<Link> links = new ArrayList<>();
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getOrderId() {
+        return orderId;
+    }
+
+    public void setOrderId(String orderId) {
+        this.orderId = orderId;
+    }
+
+    public List<Link> getLinks() {
+        return links;
+    }
+
+    public void setLinks(List<Link> links) {
+        this.links = links;
+    }
+}
diff --git a/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/PaymentDetails.java b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/PaymentDetails.java
new file mode 100644
index 0000000..284f204
--- /dev/null
+++ b/incubator/declarative-linking/src/test/java/org/glassfish/jersey/linking/integration/representations/PaymentDetails.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.linking.integration.representations;
+
+public class PaymentDetails {
+    private String creditCardNumber;
+    private String cve;
+    private String name;
+    private String expiration;
+
+    public String getCreditCardNumber() {
+        return creditCardNumber;
+    }
+
+    public void setCreditCardNumber(String creditCardNumber) {
+        this.creditCardNumber = creditCardNumber;
+    }
+
+    public String getCve() {
+        return cve;
+    }
+
+    public void setCve(String cve) {
+        this.cve = cve;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getExpiration() {
+        return expiration;
+    }
+
+    public void setExpiration(String expiration) {
+        this.expiration = expiration;
+    }
+}
diff --git a/incubator/gae-integration/pom.xml b/incubator/gae-integration/pom.xml
new file mode 100644
index 0000000..f692c90
--- /dev/null
+++ b/incubator/gae-integration/pom.xml
@@ -0,0 +1,52 @@
+<?xml version="1.0"?>
+<!--
+
+    Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+
+    This program and the accompanying materials are made available under the
+    terms of the Eclipse Public License v. 2.0, which is available at
+    http://www.eclipse.org/legal/epl-2.0.
+
+    This Source Code may also be made available under the following Secondary
+    Licenses when the conditions for such availability set forth in the
+    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+    version 2 with the GNU Classpath Exception, which is available at
+    https://www.gnu.org/software/classpath/license.html.
+
+    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.glassfish.jersey.incubator</groupId>
+        <artifactId>project</artifactId>
+        <version>2.28-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>jersey-gae-integration</artifactId>
+    <name>jersey-ext-gae-integration</name>
+
+    <description>
+        Jersey extension module providing support for Google App Engine integration.
+        NOTE: IT DOES NOT WORK YET BECAUSE OF GAE SERVLET 2.5 (see https://java.net/jira/browse/JERSEY-1853)!!!
+    </description>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-server</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.appengine</groupId>
+            <artifactId>appengine-api-1.0-sdk</artifactId>
+            <version>${gae.version}</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+</project>
diff --git a/incubator/gae-integration/src/main/java/org/glassfish/jersey/server/gae/GaeBackgroundExecutorProvider.java b/incubator/gae-integration/src/main/java/org/glassfish/jersey/server/gae/GaeBackgroundExecutorProvider.java
new file mode 100644
index 0000000..0338725
--- /dev/null
+++ b/incubator/gae-integration/src/main/java/org/glassfish/jersey/server/gae/GaeBackgroundExecutorProvider.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.server.gae;
+
+import java.util.concurrent.ThreadFactory;
+
+import org.glassfish.jersey.server.BackgroundScheduler;
+import org.glassfish.jersey.spi.ScheduledThreadPoolExecutorProvider;
+
+/**
+ * This class implements Jersey's SPI {@link org.glassfish.jersey.spi.ScheduledExecutorServiceProvider} to provide a
+ * {@link java.util.concurrent.ScheduledExecutorService} instances with a GAE specific {@link ThreadFactory} provider
+ * - {@link com.google.appengine.api.ThreadManager}.
+ *
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+@BackgroundScheduler
+class GaeBackgroundExecutorProvider extends ScheduledThreadPoolExecutorProvider {
+
+    /**
+     * Create new instance of GAE-specific background scheduled executor service provider.
+     */
+    public GaeBackgroundExecutorProvider() {
+        super("gae-jersey-background-task-scheduler");
+    }
+
+    @Override
+    public ThreadFactory getBackingThreadFactory() {
+        return com.google.appengine.api.ThreadManager.backgroundThreadFactory();
+    }
+
+    @Override
+    protected int getCorePoolSize() {
+        return 1;
+    }
+}
diff --git a/incubator/gae-integration/src/main/java/org/glassfish/jersey/server/gae/GaeFeature.java b/incubator/gae-integration/src/main/java/org/glassfish/jersey/server/gae/GaeFeature.java
new file mode 100644
index 0000000..cc99f84
--- /dev/null
+++ b/incubator/gae-integration/src/main/java/org/glassfish/jersey/server/gae/GaeFeature.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.server.gae;
+
+import javax.ws.rs.ConstrainedTo;
+import javax.ws.rs.RuntimeType;
+import javax.ws.rs.core.Feature;
+import javax.ws.rs.core.FeatureContext;
+
+/**
+ * Google App Engine integration for Jersey server runtime.
+ * <p>
+ * Register this feature in your {@link org.glassfish.jersey.server.ResourceConfig} subclass in order to be able to run
+ * your Jersey application on Google App Engine.
+ * </p>
+ *
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+@ConstrainedTo(RuntimeType.SERVER)
+public final class GaeFeature implements Feature {
+
+    @Override
+    public boolean configure(final FeatureContext context) {
+        if (!context.getConfiguration().isRegistered(GaeBackgroundExecutorProvider.class)) {
+            context.register(new GaeBackgroundExecutorProvider());
+        }
+        return true;
+    }
+
+}
diff --git a/incubator/gae-integration/src/main/java/org/glassfish/jersey/server/gae/package-info.java b/incubator/gae-integration/src/main/java/org/glassfish/jersey/server/gae/package-info.java
new file mode 100644
index 0000000..6143916
--- /dev/null
+++ b/incubator/gae-integration/src/main/java/org/glassfish/jersey/server/gae/package-info.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Public API of Google App Engine integration support.
+ *
+ * Register {@link org.glassfish.jersey.server.gae.GaeFeature} in your {@link org.glassfish.jersey.server.ResourceConfig}
+ * subclass to enable the support.
+ */
+package org.glassfish.jersey.server.gae;
diff --git a/incubator/html-json/pom.xml b/incubator/html-json/pom.xml
new file mode 100644
index 0000000..882bb46
--- /dev/null
+++ b/incubator/html-json/pom.xml
@@ -0,0 +1,117 @@
+<?xml version="1.0"?>
+<!--
+
+    Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+
+    This program and the accompanying materials are made available under the
+    terms of the Eclipse Public License v. 2.0, which is available at
+    http://www.eclipse.org/legal/epl-2.0.
+
+    This Source Code may also be made available under the following Secondary
+    Licenses when the conditions for such availability set forth in the
+    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+    version 2 with the GNU Classpath Exception, which is available at
+    https://www.gnu.org/software/classpath/license.html.
+
+    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.glassfish.jersey.incubator</groupId>
+        <artifactId>project</artifactId>
+        <version>2.26-SNAPSHOT</version>
+    </parent>
+
+    <groupId>org.glassfish.jersey.media</groupId>
+    <artifactId>html-json</artifactId>
+
+    <name>jersey-media-html-json</name>
+
+    <description>
+        JAX-RS Reader/Writer via net.java.html.json library that provides
+        JSON serialization and deserialization using lightweight (no reflection)
+        net.java.html.json library. Define your objects via @Model annotation.
+        Use them in Jersey.
+    </description>
+
+    <properties>
+        <net.java.html.version>1.0</net.java.html.version>
+    </properties>
+
+    <repositories>
+        <repository>
+            <id>netbeans</id>
+            <name>NetBeans</name>
+            <url>http://bits.netbeans.org/maven2/</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>javax.ws.rs</groupId>
+            <artifactId>javax.ws.rs-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.netbeans.html</groupId>
+            <artifactId>net.java.html.json</artifactId>
+            <version>${net.java.html.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.netbeans.api</groupId>
+            <artifactId>org-openide-util-lookup</artifactId>
+            <version>RELEASE80</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-client</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.annotation</groupId>
+            <artifactId>javax.annotation-api</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.test-framework</groupId>
+            <artifactId>jersey-test-framework-core</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.connectors</groupId>
+            <artifactId>jersey-apache-connector</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.test-framework.providers</groupId>
+            <artifactId>jersey-test-framework-provider-bundle</artifactId>
+            <version>${project.version}</version>
+            <type>pom</type>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.netbeans.html</groupId>
+            <artifactId>ko-ws-tyrus</artifactId>
+            <version>${net.java.html.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+        <!-- Overwrite Grizzly dependency defined in ko-ws-tyrus -->
+        <dependency>
+            <groupId>org.glassfish.grizzly</groupId>
+            <artifactId>grizzly-framework</artifactId>
+            <version>${grizzly2.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/incubator/html-json/src/main/java/org/glassfish/jersey/media/htmljson/HtmlJsonProvider.java b/incubator/html-json/src/main/java/org/glassfish/jersey/media/htmljson/HtmlJsonProvider.java
new file mode 100644
index 0000000..b220eda
--- /dev/null
+++ b/incubator/html-json/src/main/java/org/glassfish/jersey/media/htmljson/HtmlJsonProvider.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.media.htmljson;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Array;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.MessageBodyWriter;
+
+import org.openide.util.lookup.ServiceProvider;
+import org.openide.util.lookup.ServiceProviders;
+
+import net.java.html.BrwsrCtx;
+import net.java.html.json.Model;
+import net.java.html.json.Models;
+import net.java.html.json.Property;
+
+/**
+ * Implementation of Jersey's message body reader and writer that
+ * can handle reading and writing of JSON models generated by {@link Model}
+ * annotation provided by
+ * <a target="_blank" href="http://bck2brwsr.apidesign.org/javadoc/net.java.html.json/">net.java.html.json</a>
+ * library. Include
+ * this JAR in your project and you can then use your
+ * model classes as Jersey's entities.
+ * <p>
+ * <pre>
+ * {@link Model @Model}(className="Query", properties={
+ *   {@link Property @Property}(name="items", type=Item.<b>class</b>, array=true)
+ * })
+ * <b>class</b> QueryImpl {
+ *
+ *   {@link Model @Model}(className="Item", properties={
+ *     {@link Property @Property}(name="id", type=String.<b>class</b>),
+ *     {@link Property @Property}(name="kind", type=Kind.<b>class</b>)
+ *   })
+ *   <b>class</b> ItemImpl {
+ *   }
+ *
+ *   <b>enum</b> Kind {
+ *     GOOD, BAD
+ *   }
+ *
+ *   <b>public static</b> List{@code <Item>} doQuery() {
+ *     {@link WebTarget} target = ...;
+ *     Query q = target.request(MediaType.APPLICATION_JSON).get().readEntity(Query.<b>class</b>);
+ *     return q.getItems();
+ *   }
+ * }
+ * </pre>
+ *
+ * @author Jaroslav Tulach (jtulach at netbeans.org)
+ */
+@ServiceProviders({
+        @ServiceProvider(service = MessageBodyWriter.class),
+        @ServiceProvider(service = MessageBodyReader.class)
+})
+public final class HtmlJsonProvider implements MessageBodyWriter<Object>, MessageBodyReader<Object> {
+
+    @Override
+    public boolean isWriteable(Class clazz, Type type, Annotation[] antns, MediaType mt) {
+        if (!mt.isCompatible(MediaType.APPLICATION_JSON_TYPE)) {
+            return false;
+        }
+        if (clazz.isArray()) {
+            return Models.isModel(clazz.getComponentType());
+        }
+        if (java.util.List.class.isAssignableFrom(clazz)) {
+            if (type instanceof ParameterizedType) {
+                ParameterizedType pt = (ParameterizedType) type;
+                Type[] args = pt.getActualTypeArguments();
+                if (args.length == 1 && args[0] instanceof Class) {
+                    return Models.isModel((Class<?>) args[0]);
+                }
+            }
+        }
+        return Models.isModel(clazz);
+    }
+
+    @Override
+    public long getSize(Object t, Class type, Type type1, Annotation[] antns, MediaType mt) {
+        return -1;
+    }
+
+    @Override
+    public void writeTo(Object t, Class type, Type type1, Annotation[] antns, MediaType mt, MultivaluedMap mm, OutputStream out)
+            throws IOException, WebApplicationException {
+        dump(t, out);
+    }
+
+    private void dump(Object t, OutputStream out) throws IOException {
+        if (t instanceof Object[]) {
+            Object[] arr = (Object[]) t;
+            out.write('[');
+            for (int i = 0; i < arr.length; i++) {
+                if (i > 0) {
+                    out.write(',');
+                }
+                dump(arr[i], out);
+            }
+            out.write(']');
+        } else {
+            out.write(t.toString().getBytes("UTF-8"));
+        }
+    }
+
+    @Override
+    public boolean isReadable(Class<?> type, Type type1, Annotation[] antns, MediaType mt) {
+        return isWriteable(type, type1, antns, mt);
+    }
+
+    @Override
+    public Object readFrom(Class<Object> clazz,
+                           Type type, Annotation[] antns, MediaType mt,
+                           MultivaluedMap<String, String> mm,
+                           InputStream in) throws IOException, WebApplicationException {
+        BrwsrCtx def = BrwsrCtx.findDefault(HtmlJsonProvider.class);
+        if (clazz.isArray()) {
+            List<Object> res = new ArrayList<>();
+            final Class<?> cmp = clazz.getComponentType();
+            Models.parse(def, cmp, in, res);
+            Object[] arr = (Object[]) Array.newInstance(cmp, res.size());
+            return res.toArray(arr);
+        }
+        if (clazz.isAssignableFrom(java.util.List.class)
+                && type instanceof ParameterizedType
+                && ((ParameterizedType) type).getActualTypeArguments().length == 1
+                && ((ParameterizedType) type).getActualTypeArguments()[0] instanceof Class) {
+            List<Object> res = new ArrayList<>();
+            final Class<?> cmp = (Class<?>) ((ParameterizedType) type).getActualTypeArguments()[0];
+            Models.parse(def, cmp, in, res);
+            return res;
+        }
+        return Models.parse(def, clazz, in);
+    }
+}
diff --git a/incubator/html-json/src/main/java/org/glassfish/jersey/media/htmljson/internal/HtmlJsonAutoDiscoverable.java b/incubator/html-json/src/main/java/org/glassfish/jersey/media/htmljson/internal/HtmlJsonAutoDiscoverable.java
new file mode 100644
index 0000000..7b3b56a
--- /dev/null
+++ b/incubator/html-json/src/main/java/org/glassfish/jersey/media/htmljson/internal/HtmlJsonAutoDiscoverable.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2014, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.media.htmljson.internal;
+
+import javax.annotation.Priority;
+import javax.ws.rs.core.Configuration;
+import javax.ws.rs.core.FeatureContext;
+
+import org.glassfish.jersey.internal.spi.AutoDiscoverable;
+import org.glassfish.jersey.media.htmljson.HtmlJsonProvider;
+
+/**
+ * @author Michal Gajdos
+ */
+@Priority(AutoDiscoverable.DEFAULT_PRIORITY)
+public class HtmlJsonAutoDiscoverable implements AutoDiscoverable {
+
+    @Override
+    public void configure(final FeatureContext context) {
+        final Configuration config = context.getConfiguration();
+
+        if (!config.isRegistered(HtmlJsonProvider.class)) {
+            context.register(HtmlJsonProvider.class);
+        }
+    }
+}
diff --git a/incubator/html-json/src/main/java/org/glassfish/jersey/media/htmljson/package-info.java b/incubator/html-json/src/main/java/org/glassfish/jersey/media/htmljson/package-info.java
new file mode 100644
index 0000000..5a8cf74
--- /dev/null
+++ b/incubator/html-json/src/main/java/org/glassfish/jersey/media/htmljson/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/**
+ * Jersey package with entity provider that allows usage of {@code net.java.html.json}.
+ */
+package org.glassfish.jersey.media.htmljson;
diff --git a/incubator/html-json/src/main/resources/META-INF/services/org.glassfish.jersey.internal.spi.AutoDiscoverable b/incubator/html-json/src/main/resources/META-INF/services/org.glassfish.jersey.internal.spi.AutoDiscoverable
new file mode 100644
index 0000000..4709b74
--- /dev/null
+++ b/incubator/html-json/src/main/resources/META-INF/services/org.glassfish.jersey.internal.spi.AutoDiscoverable
@@ -0,0 +1 @@
+org.glassfish.jersey.media.htmljson.internal.HtmlJsonAutoDiscoverable
\ No newline at end of file
diff --git a/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/AbstractTypeTester.java b/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/AbstractTypeTester.java
new file mode 100644
index 0000000..5213a80
--- /dev/null
+++ b/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/AbstractTypeTester.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.media.htmljson;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.HashSet;
+
+import javax.ws.rs.ConstrainedTo;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.RuntimeType;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.ext.Provider;
+import javax.ws.rs.ext.WriterInterceptor;
+import javax.ws.rs.ext.WriterInterceptorContext;
+
+import org.glassfish.jersey.client.ClientConfig;
+import org.glassfish.jersey.message.internal.ReaderWriter;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.test.JerseyTest;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Abstract entity type tester base class.
+ *
+ * @author Paul Sandoz
+ * @author Martin Matula
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public abstract class AbstractTypeTester extends JerseyTest {
+
+    protected static byte[] requestEntity;
+
+    public abstract static class AResource<T> {
+
+        @POST
+        public T post(T t) {
+            return t;
+        }
+    }
+
+    public static class RequestEntityInterceptor implements WriterInterceptor {
+
+        @Override
+        public void aroundWriteTo(WriterInterceptorContext writerInterceptorContext) throws IOException, WebApplicationException {
+            OutputStream original = writerInterceptorContext.getOutputStream();
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            writerInterceptorContext.setOutputStream(baos);
+            writerInterceptorContext.proceed();
+            requestEntity = baos.toByteArray();
+            original.write(requestEntity);
+        }
+    }
+
+    /**
+     * Looks for all resources and providers declared as inner classes of the subclass of this class
+     * and adds them to the returned ResourceConfig (unless constrained to client side).
+     *
+     * @return ResourceConfig instance
+     */
+    @Override
+    protected Application configure() {
+        HashSet<Class<?>> classes = new HashSet<Class<?>>();
+
+        for (Class<?> cls : getClass().getDeclaredClasses()) {
+            if (cls.getAnnotation(Path.class) != null) {
+                classes.add(cls);
+            } else if (cls.getAnnotation(Provider.class) != null) {
+                final ConstrainedTo constrainedTo = cls.getAnnotation(ConstrainedTo.class);
+                if (constrainedTo == null || constrainedTo.value() == RuntimeType.SERVER) {
+                    classes.add(cls);
+                }
+            }
+        }
+
+        return new ResourceConfig(classes);
+    }
+
+    /**
+     * Looks for all providers declared as inner classes of the subclass of this class
+     * and adds them to the client configuration (unless constrained to server side).
+     */
+    @Override
+    protected void configureClient(ClientConfig config) {
+        config.register(RequestEntityInterceptor.class);
+
+        for (Class<?> cls : getClass().getDeclaredClasses()) {
+            if (cls.getAnnotation(Provider.class) != null) {
+                final ConstrainedTo constrainedTo = cls.getAnnotation(ConstrainedTo.class);
+                if (constrainedTo == null || constrainedTo.value() == RuntimeType.CLIENT) {
+                    config.register(cls);
+                }
+            }
+        }
+    }
+
+    protected <T> void _test(T in, Class resource) {
+        _test(in, resource, true);
+    }
+
+    protected <T> void _test(T in, Class resource, MediaType m) {
+        _test(in, resource, m, true);
+    }
+
+    protected <T> void _test(T in, Class resource, boolean verify) {
+        _test(in, resource, MediaType.TEXT_PLAIN_TYPE, verify);
+    }
+
+    protected <T> void _test(T in, Class resource, MediaType m, boolean verify) {
+        WebTarget target = target(resource.getSimpleName());
+        Response response = target.request().post(Entity.entity(in, m));
+
+        byte[] inBytes = requestEntity;
+        byte[] outBytes = getEntityAsByteArray(response);
+
+        if (verify) {
+            _verify(inBytes, outBytes);
+        }
+    }
+
+    protected static void _verify(byte[] in, byte[] out) {
+        assertEquals(in.length, out.length);
+        for (int i = 0; i < in.length; i++) {
+            if (in[i] != out[i]) {
+                assertEquals("Index: " + i, in[i], out[i]);
+            }
+        }
+    }
+
+    protected static byte[] getEntityAsByteArray(Response r) {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try {
+            ReaderWriter.writeTo(r.readEntity(InputStream.class), baos);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return baos.toByteArray();
+    }
+}
diff --git a/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/ComputedPropertyTest.java b/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/ComputedPropertyTest.java
new file mode 100644
index 0000000..eb5a839
--- /dev/null
+++ b/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/ComputedPropertyTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.media.htmljson;
+
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+import net.java.html.json.ComputedProperty;
+import net.java.html.json.Model;
+import net.java.html.json.Property;
+
+/** Can use the same code on server as well as client.
+ *
+ * @author Jaroslav Tulach
+ */
+@Model(className = "Person", properties = {
+        @Property(name = "firstName", type = String.class),
+        @Property(name = "lastName", type = String.class)
+})
+public class ComputedPropertyTest extends AbstractTypeTester {
+
+    @ComputedProperty
+    static String fullName(String firstName, String lastName) {
+        return firstName + " " + lastName;
+    }
+
+    //
+    // server side
+    //
+    @Path("empty")
+    public static class TestResource {
+
+        @PUT
+        @Path("fullName")
+        public String myBean(Person p) {
+            return p.getFullName();
+        }
+    }
+
+    //
+    // Client using the model to connect to server
+    //
+
+    @Test
+    public void askForFullName() {
+        WebTarget target = target("empty/fullName");
+
+        Person p = new Person();
+        p.setFirstName("Jaroslav");
+        p.setLastName("Tulach");
+
+        final Response response = target.request().put(Entity.entity(p, MediaType.APPLICATION_JSON_TYPE));
+
+        assertEquals(200, response.getStatus());
+        assertEquals("Jaroslav Tulach", response.readEntity(String.class));
+    }
+}
diff --git a/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/ModelEntityOnArrayTest.java b/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/ModelEntityOnArrayTest.java
new file mode 100644
index 0000000..a1e01c7
--- /dev/null
+++ b/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/ModelEntityOnArrayTest.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.media.htmljson;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+
+import org.glassfish.jersey.test.TestProperties;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import net.java.html.json.Model;
+
+/**
+ * Reading and writing class generated by {@link Model} as
+ * arrays.
+ *
+ * @author Jaroslav Tulach
+ */
+public class ModelEntityOnArrayTest extends AbstractTypeTester {
+
+    @Path("empty")
+    public static class TestResource {
+
+        @POST
+        @Path("mybean")
+        public String myBean(MyBean[] bean) {
+            if (bean.length != 2) {
+                return "ERROR, length: " + bean.length;
+            }
+            if (!bean[0].getValue().equals("Hello")) {
+                return "ERROR, [0].value = " + bean[0].getValue();
+            }
+            if (!bean[1].getValue().equals("Ahoy")) {
+                return "ERROR, [1].value = " + bean[1].getValue();
+            }
+            return "PASSED";
+        }
+
+        @GET
+        @Path("getbean")
+        public Response getBean(@Context HttpHeaders headers) {
+            MyBean teb = new MyBean();
+            teb.setValue("hello");
+            return Response.ok().type(MediaType.APPLICATION_JSON_TYPE).entity(new MyBean[] {teb}).build();
+        }
+    }
+
+    public ModelEntityOnArrayTest() {
+        enable(TestProperties.LOG_TRAFFIC);
+    }
+
+    @Test
+    public void myBeanAndPut() {
+        WebTarget target = target("empty/mybean");
+
+        MyBean mb = new MyBean();
+        mb.setValue("Hello");
+        MyBean ah = new MyBean();
+        ah.setValue("Ahoy");
+        MyBean[] arr = new MyBean[] {mb, ah};
+
+        final Response response = target.request().post(Entity.entity(arr, MediaType.APPLICATION_JSON_TYPE));
+
+        assertEquals(200, response.getStatus());
+        assertEquals("PASSED", response.readEntity(String.class));
+    }
+
+    @Test
+    public void doReadWrite() throws Exception {
+        MyBean mb = new MyBean();
+        mb.setValue("Hello");
+        MyBean ah = new MyBean();
+        ah.setValue("Ahoy");
+        MyBean[] arr = new MyBean[] {mb, ah};
+
+        ByteArrayOutputStream os = new ByteArrayOutputStream();
+        os.write('[');
+        os.write(arr[0].toString().getBytes("UTF-8"));
+        os.write(',');
+        os.write(arr[1].toString().getBytes("UTF-8"));
+        os.write(']');
+        os.close();
+
+        ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
+
+        final Class c = arr.getClass();
+        Object ret = new HtmlJsonProvider().readFrom(c, null, null, MediaType.APPLICATION_JSON_TYPE, null, is);
+
+        assertTrue("It is array: " + ret, ret instanceof MyBean[]);
+        MyBean[] res = (MyBean[]) ret;
+        assertEquals("Two items: ", 2, res.length);
+        assertEquals(arr[0], res[0]);
+        assertEquals(arr[1], res[1]);
+    }
+
+    @Test
+    public void myBeanAndGet() {
+        WebTarget target = target("empty/getbean");
+        final Response response = target.request(MediaType.APPLICATION_JSON).get();
+        assertEquals(200, response.getStatus());
+        final MyBean[] teb = response.readEntity(MyBean[].class);
+
+        assertEquals("value", "hello", teb[0].getValue());
+    }
+}
diff --git a/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/ModelEntityOnListTest.java b/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/ModelEntityOnListTest.java
new file mode 100644
index 0000000..2dffdb7
--- /dev/null
+++ b/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/ModelEntityOnListTest.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.media.htmljson;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.GenericEntity;
+import javax.ws.rs.core.GenericType;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+
+import org.glassfish.jersey.test.TestProperties;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+import net.java.html.json.Model;
+
+/**
+ * Reading and writing class generated by {@link Model} as
+ * {@link List}.
+ *
+ * @author Jaroslav Tulach
+ */
+public class ModelEntityOnListTest extends AbstractTypeTester {
+
+    @Path("empty")
+    public static class TestResource {
+
+        @POST
+        @Path("mybean")
+        public String myBean(List<MyBean> bean) {
+            if (bean.size() != 2) {
+                return "ERROR, length: " + bean.size();
+            }
+            if (!bean.get(0).getValue().equals("Hello")) {
+                return "ERROR, [0].value = " + bean.get(0).getValue();
+            }
+            if (!bean.get(1).getValue().equals("Ahoy")) {
+                return "ERROR, [1].value = " + bean.get(1).getValue();
+            }
+            return "PASSED";
+        }
+
+        @GET
+        @Path("getbean")
+        public Response getBean(@Context HttpHeaders headers) {
+            MyBean teb = new MyBean();
+            teb.setValue("hello");
+            List<MyBean> l = new ArrayList<MyBean>();
+            l.add(teb);
+            GenericEntity<List<MyBean>> ge = new GenericEntity<List<MyBean>>(l) {};
+            return Response.ok().type(MediaType.APPLICATION_JSON_TYPE).entity(ge).build();
+        }
+    }
+
+    public ModelEntityOnListTest() {
+        enable(TestProperties.LOG_TRAFFIC);
+    }
+
+    @Test
+    public void myBeanAndPut() {
+        WebTarget target = target("empty/mybean");
+
+        MyBean mb = new MyBean();
+        mb.setValue("Hello");
+        MyBean ah = new MyBean();
+        ah.setValue("Ahoy");
+        GenericEntity<List<MyBean>> ge = new GenericEntity<List<MyBean>>(Arrays.asList(mb, ah)) {};
+        final Response response = target.request().post(Entity.entity(ge, MediaType.APPLICATION_JSON_TYPE));
+
+        assertEquals(200, response.getStatus());
+        assertEquals("PASSED", response.readEntity(String.class));
+    }
+
+    @Test
+    public void myBeanAndGet() {
+        WebTarget target = target("empty/getbean");
+        final Response response = target.request(MediaType.APPLICATION_JSON).get();
+        assertEquals(200, response.getStatus());
+        GenericType<List<MyBean>> ge = new GenericType<List<MyBean>>() {};
+        List<MyBean> teb = response.readEntity(ge);
+
+        assertEquals("one element in list: " + teb, 1, teb.size());
+        assertEquals("value", "hello", teb.get(0).getValue());
+    }
+}
diff --git a/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/ModelEntityTest.java b/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/ModelEntityTest.java
new file mode 100644
index 0000000..dfc996f
--- /dev/null
+++ b/incubator/html-json/src/test/java/org/glassfish/jersey/media/htmljson/ModelEntityTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2013, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.media.htmljson;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+
+import org.glassfish.jersey.test.TestProperties;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+import net.java.html.json.Model;
+import net.java.html.json.Property;
+
+/**
+ * Reading and writing class generated by {@link Model}.
+ *
+ * @author Jaroslav Tulach
+ */
+public class ModelEntityTest extends AbstractTypeTester {
+
+    @Model(className = "MyBean", properties = {
+            @Property(name = "value", type = String.class)
+    })
+    static class MB {
+    }
+
+    @Path("empty")
+    public static class TestResource {
+        @POST
+        @Path("mybean")
+        public String myBean(MyBean bean) {
+            return (bean.getValue().equals("Hello")) ? "PASSED" : "ERROR";
+        }
+
+        @GET
+        @Path("getbean")
+        public Response getBean(@Context HttpHeaders headers) {
+            MyBean teb = new MyBean();
+            teb.setValue("hello");
+            return Response.ok().type(MediaType.APPLICATION_JSON_TYPE).entity(teb).build();
+        }
+    }
+
+    public ModelEntityTest() {
+        enable(TestProperties.LOG_TRAFFIC);
+    }
+
+    @Test
+    public void myBeanAndPut() {
+        WebTarget target = target("empty/mybean");
+
+        MyBean mb = new MyBean();
+        mb.setValue("Hello");
+
+        final Response response = target.request().post(Entity.entity(mb, MediaType.APPLICATION_JSON_TYPE));
+
+        assertEquals(200, response.getStatus());
+        assertEquals("PASSED", response.readEntity(String.class));
+    }
+
+    @Test
+    public void myBeanAndGet() {
+        WebTarget target = target("empty/getbean");
+        final Response response = target.request(MediaType.APPLICATION_JSON).get();
+        assertEquals(200, response.getStatus());
+        final MyBean teb = response.readEntity(MyBean.class);
+
+        assertEquals("value", "hello", teb.getValue());
+    }
+}
diff --git a/incubator/kryo/README.md b/incubator/kryo/README.md
new file mode 100644
index 0000000..4e10678
--- /dev/null
+++ b/incubator/kryo/README.md
@@ -0,0 +1,36 @@
+[//]: # " Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved. "
+[//]: # "  "
+[//]: # " This program and the accompanying materials are made available under the "
+[//]: # " terms of the Eclipse Public License v. 2.0, which is available at "
+[//]: # " http://www.eclipse.org/legal/epl-2.0. "
+[//]: # "  "
+[//]: # " This Source Code may also be made available under the following Secondary "
+[//]: # " Licenses when the conditions for such availability set forth in the "
+[//]: # " Eclipse Public License v. 2.0 are satisfied: GNU General Public License, "
+[//]: # " version 2 with the GNU Classpath Exception, which is available at "
+[//]: # " https://www.gnu.org/software/classpath/license.html. "
+[//]: # "  "
+[//]: # " SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 "
+
+This is experimental module that provides JAX-RS Message Body Writer & Reader using Kryo serialization framework.
+
+# How to use it
+
+Add dependency to the module:
+
+```xml
+<dependency>
+    <groupId>org.glassfish.jersey.media</groupId>
+    <artifactId>jersey-media-kryo</artifactId>
+    <version>${jersey.version}</version>
+</dependency>
+```
+
+And now you can consume or produce entities (de)serialized by Kryo. Just use `application/x-kryo` MIME type, e.g.:
+
+```java
+@Path("/rest")
+@Consumes("application/x-kryo")
+@Produces("application/x-kryo")
+public class MyResource { ... }
+```
diff --git a/incubator/kryo/pom.xml b/incubator/kryo/pom.xml
new file mode 100644
index 0000000..a6a7757
--- /dev/null
+++ b/incubator/kryo/pom.xml
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+
+    This program and the accompanying materials are made available under the
+    terms of the Eclipse Public License v. 2.0, which is available at
+    http://www.eclipse.org/legal/epl-2.0.
+
+    This Source Code may also be made available under the following Secondary
+    Licenses when the conditions for such availability set forth in the
+    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+    version 2 with the GNU Classpath Exception, which is available at
+    https://www.gnu.org/software/classpath/license.html.
+
+    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.glassfish.jersey.incubator</groupId>
+        <artifactId>project</artifactId>
+        <version>2.28-SNAPSHOT</version>
+    </parent>
+
+    <groupId>org.glassfish.jersey.media</groupId>
+    <artifactId>jersey-media-kryo</artifactId>
+    <name>jersey-media-kryo</name>
+
+    <description>
+        Jersey/JAX-RS Message Body Writer and Reader using Kryo serialization framework
+    </description>
+
+    <dependencies>
+        <dependency>
+            <groupId>javax.ws.rs</groupId>
+            <artifactId>javax.ws.rs-api</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-common</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.esotericsoftware</groupId>
+            <artifactId>kryo</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.glassfish.jersey.test-framework.providers</groupId>
+            <artifactId>jersey-test-framework-provider-grizzly2</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/incubator/kryo/src/main/java/org/glassfish/jersey/kryo/KryoFeature.java b/incubator/kryo/src/main/java/org/glassfish/jersey/kryo/KryoFeature.java
new file mode 100644
index 0000000..63545fa
--- /dev/null
+++ b/incubator/kryo/src/main/java/org/glassfish/jersey/kryo/KryoFeature.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.kryo;
+
+import javax.ws.rs.core.Configuration;
+import javax.ws.rs.core.Feature;
+import javax.ws.rs.core.FeatureContext;
+
+import org.glassfish.jersey.Beta;
+import org.glassfish.jersey.kryo.internal.KryoMessageBodyProvider;
+
+/**
+ * Feature used to register Kryo providers.
+ *
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ */
+@Beta
+public class KryoFeature implements Feature {
+
+    @Override
+    public boolean configure(final FeatureContext context) {
+        final Configuration config = context.getConfiguration();
+
+        if (!config.isRegistered(KryoMessageBodyProvider.class)) {
+            context.register(KryoMessageBodyProvider.class);
+        }
+
+        return true;
+    }
+
+}
diff --git a/incubator/kryo/src/main/java/org/glassfish/jersey/kryo/internal/KryoAutoDiscoverable.java b/incubator/kryo/src/main/java/org/glassfish/jersey/kryo/internal/KryoAutoDiscoverable.java
new file mode 100644
index 0000000..73107ca
--- /dev/null
+++ b/incubator/kryo/src/main/java/org/glassfish/jersey/kryo/internal/KryoAutoDiscoverable.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.kryo.internal;
+
+import javax.ws.rs.core.FeatureContext;
+
+import javax.annotation.Priority;
+
+import org.glassfish.jersey.internal.spi.AutoDiscoverable;
+import org.glassfish.jersey.kryo.KryoFeature;
+
+/**
+ * {@link AutoDiscoverable} registering {@link KryoFeature} if the feature is not already registered.
+ *
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ */
+@Priority(AutoDiscoverable.DEFAULT_PRIORITY)
+public class KryoAutoDiscoverable implements AutoDiscoverable {
+
+    @Override
+    public void configure(final FeatureContext context) {
+        if (!context.getConfiguration().isRegistered(KryoFeature.class)) {
+            context.register(KryoFeature.class);
+        }
+    }
+
+}
diff --git a/incubator/kryo/src/main/java/org/glassfish/jersey/kryo/internal/KryoMessageBodyProvider.java b/incubator/kryo/src/main/java/org/glassfish/jersey/kryo/internal/KryoMessageBodyProvider.java
new file mode 100644
index 0000000..755c290
--- /dev/null
+++ b/incubator/kryo/src/main/java/org/glassfish/jersey/kryo/internal/KryoMessageBodyProvider.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.kryo.internal;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.Produces;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.Provider;
+
+import com.esotericsoftware.kryo.Kryo;
+import com.esotericsoftware.kryo.io.Input;
+import com.esotericsoftware.kryo.io.Output;
+import com.esotericsoftware.kryo.pool.KryoCallback;
+import com.esotericsoftware.kryo.pool.KryoFactory;
+import com.esotericsoftware.kryo.pool.KryoPool;
+
+/**
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ */
+@Provider
+@Consumes("application/x-kryo")
+@Produces("application/x-kryo")
+public class KryoMessageBodyProvider implements MessageBodyWriter<Object>, MessageBodyReader<Object> {
+
+    private final KryoPool kryoPool;
+
+    public KryoMessageBodyProvider() {
+        final KryoFactory kryoFactory = new KryoFactory() {
+            public Kryo create() {
+                final Kryo kryo = new Kryo();
+                //TODO: configure kryo instance, customize settings
+                //TODO: e.g. looking for Kryo via ContextResolver (like Jackson)
+                return kryo;
+            }
+        };
+        kryoPool = new KryoPool.Builder(kryoFactory).softReferences().build();
+    }
+
+    //
+    // MessageBodyWriter
+    //
+
+    @Override
+    public long getSize(final Object object, final Class<?> type, final Type genericType,
+                        final Annotation[] annotations, final MediaType mediaType) {
+        return -1;
+    }
+
+    @Override
+    public boolean isWriteable(final Class<?> type, final Type genericType,
+                               final Annotation[] annotations, final MediaType mediaType) {
+        return true;
+    }
+
+    @Override
+    public void writeTo(final Object object, final Class<?> type, final Type genericType,
+                        final Annotation[] annotations, final MediaType mediaType,
+                        final MultivaluedMap<String, Object> httpHeaders, final OutputStream entityStream)
+            throws IOException, WebApplicationException {
+        final Output output = new Output(entityStream);
+        kryoPool.run(new KryoCallback() {
+            public Object execute(Kryo kryo) {
+                kryo.writeObject(output, object);
+                return null;
+            }
+        });
+        output.flush();
+    }
+
+    //
+    // MessageBodyReader
+    //
+
+    @Override
+    public boolean isReadable(final Class<?> type, final Type genericType,
+                              final Annotation[] annotations, final MediaType mediaType) {
+        return true;
+    }
+
+    @Override
+    public Object readFrom(final Class<Object> type, final Type genericType,
+                           final Annotation[] annotations, final MediaType mediaType,
+                           final MultivaluedMap<String, String> httpHeaders,
+                           final InputStream entityStream) throws IOException, WebApplicationException {
+        final Input input = new Input(entityStream);
+
+        return kryoPool.run(new KryoCallback() {
+            public Object execute(Kryo kryo) {
+                return kryo.readObject(input, type);
+            }
+        });
+    }
+
+}
diff --git a/incubator/kryo/src/main/resources/META-INF/services/org.glassfish.jersey.internal.spi.AutoDiscoverable b/incubator/kryo/src/main/resources/META-INF/services/org.glassfish.jersey.internal.spi.AutoDiscoverable
new file mode 100644
index 0000000..870630d
--- /dev/null
+++ b/incubator/kryo/src/main/resources/META-INF/services/org.glassfish.jersey.internal.spi.AutoDiscoverable
@@ -0,0 +1 @@
+org.glassfish.jersey.kryo.internal.KryoAutoDiscoverable
diff --git a/incubator/kryo/src/test/java/org/glassfish/jersey/kryo/JaxRsApplication.java b/incubator/kryo/src/test/java/org/glassfish/jersey/kryo/JaxRsApplication.java
new file mode 100644
index 0000000..fae6a4c
--- /dev/null
+++ b/incubator/kryo/src/test/java/org/glassfish/jersey/kryo/JaxRsApplication.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.kryo;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.ws.rs.core.Application;
+
+/**
+ * Test case JAX-RS application.
+ *
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ */
+public class JaxRsApplication extends Application {
+
+    static final Set<Class<?>> APP_CLASSES = new HashSet<Class<?>>() {{
+        add(PersonResource.class);
+    }};
+
+    @Override
+    public Set<Class<?>> getClasses() {
+        return APP_CLASSES;
+    }
+
+}
diff --git a/incubator/kryo/src/test/java/org/glassfish/jersey/kryo/Person.java b/incubator/kryo/src/test/java/org/glassfish/jersey/kryo/Person.java
new file mode 100644
index 0000000..ac17889
--- /dev/null
+++ b/incubator/kryo/src/test/java/org/glassfish/jersey/kryo/Person.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.kryo;
+
+import java.util.Objects;
+
+/**
+ * Test data bean.
+ *
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ */
+public class Person {
+
+    public String name;
+    public int age;
+    public String address;
+
+    public Person(String name, int age, String address) {
+        this.name = name;
+        this.age = age;
+        this.address = address;
+    }
+
+    public Person() {
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 7;
+        hash = 19 * hash + Objects.hashCode(this.name);
+        hash = 19 * hash + this.age;
+        hash = 19 * hash + Objects.hashCode(this.address);
+        return hash;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final Person other = (Person) obj;
+        if (!Objects.equals(this.name, other.name)) {
+            return false;
+        }
+        if (this.age != other.age) {
+            return false;
+        }
+        return (Objects.equals(this.address, other.address));
+    }
+}
diff --git a/incubator/kryo/src/test/java/org/glassfish/jersey/kryo/PersonResource.java b/incubator/kryo/src/test/java/org/glassfish/jersey/kryo/PersonResource.java
new file mode 100644
index 0000000..58981a8
--- /dev/null
+++ b/incubator/kryo/src/test/java/org/glassfish/jersey/kryo/PersonResource.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.kryo;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+
+/**
+ * Test resource.
+ *
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ */
+@Path("/")
+@Consumes("application/x-kryo")
+@Produces("application/x-kryo")
+public class PersonResource {
+
+    @POST
+    public Person echo(final Person person) {
+        return person;
+    }
+
+    @PUT
+    public void put(final Person person) {
+    }
+
+    @GET
+    public Person get() {
+        return new Person("Wolfgang", 21, "Salzburg");
+    }
+
+}
diff --git a/incubator/kryo/src/test/java/org/glassfish/jersey/kryo/PersonResourceTest.java b/incubator/kryo/src/test/java/org/glassfish/jersey/kryo/PersonResourceTest.java
new file mode 100644
index 0000000..4d4eaea
--- /dev/null
+++ b/incubator/kryo/src/test/java/org/glassfish/jersey/kryo/PersonResourceTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2015, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.kryo;
+
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.Response;
+
+import org.glassfish.jersey.client.ClientConfig;
+import org.glassfish.jersey.test.JerseyTest;
+import org.glassfish.jersey.test.TestProperties;
+
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Test for kryo resource.
+ *
+ * @author Libor Kramolis (libor.kramolis at oracle.com)
+ */
+public class PersonResourceTest extends JerseyTest {
+
+    @Override
+    protected Application configure() {
+        enable(TestProperties.LOG_TRAFFIC);
+        enable(TestProperties.DUMP_ENTITY);
+        return new JaxRsApplication();
+    }
+
+    @Override
+    protected void configureClient(final ClientConfig config) {
+    }
+
+    @Test
+    public void testGet() {
+        final Person getResponse = target().request().get(Person.class);
+        assertEquals("Wolfgang", getResponse.name);
+        assertEquals(21, getResponse.age);
+        assertEquals("Salzburg", getResponse.address);
+    }
+
+    @Test
+    public void testPost() {
+        final Person[] testData = new Person[] {new Person("Joseph", 23, "Nazareth"), new Person("Mary", 18, "Nazareth")};
+        for (Person original : testData) {
+            final Person postResponse = target().request()
+                    .post(Entity.entity(original, "application/x-kryo"), Person.class);
+            assertEquals(original, postResponse);
+        }
+    }
+
+    @Test
+    public void testPut() {
+        final Response putResponse = target().request().put(Entity.entity(new Person("Jules", 12, "Paris"),
+                "application/x-kryo"));
+        assertEquals(204, putResponse.getStatus());
+    }
+
+}
diff --git a/incubator/open-tracing/pom.xml b/incubator/open-tracing/pom.xml
new file mode 100644
index 0000000..f96771e
--- /dev/null
+++ b/incubator/open-tracing/pom.xml
@@ -0,0 +1,95 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+
+    This program and the accompanying materials are made available under the
+    terms of the Eclipse Public License v. 2.0, which is available at
+    http://www.eclipse.org/legal/epl-2.0.
+
+    This Source Code may also be made available under the following Secondary
+    Licenses when the conditions for such availability set forth in the
+    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+    version 2 with the GNU Classpath Exception, which is available at
+    https://www.gnu.org/software/classpath/license.html.
+
+    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.glassfish.jersey.incubator</groupId>
+        <artifactId>project</artifactId>
+        <version>2.28-SNAPSHOT</version>
+    </parent>
+
+    <groupId>org.glassfish.jersey.incubator</groupId>
+    <artifactId>jersey-open-tracing</artifactId>
+    <packaging>jar</packaging>
+
+    <name>jersey-open-tracing</name>
+
+    <description>
+        Jersey support for OpenTracing.
+    </description>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.opentracing</groupId>
+            <artifactId>opentracing-api</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>io.opentracing</groupId>
+            <artifactId>opentracing-util</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-common</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.glassfish.jersey.core</groupId>
+            <artifactId>jersey-server</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.glassfish.jersey.test-framework.providers</groupId>
+            <artifactId>jersey-test-framework-provider-grizzly2</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>com.sun.istack</groupId>
+                <artifactId>maven-istack-commons-plugin</artifactId>
+                <inherited>true</inherited>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>build-helper-maven-plugin</artifactId>
+                <inherited>true</inherited>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.felix</groupId>
+                <artifactId>maven-bundle-plugin</artifactId>
+                <inherited>true</inherited>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingApplicationEventListener.java b/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingApplicationEventListener.java
new file mode 100644
index 0000000..d155760
--- /dev/null
+++ b/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingApplicationEventListener.java
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.opentracing;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import javax.ws.rs.container.ContainerRequestFilter;
+import javax.ws.rs.container.ContainerResponseFilter;
+
+import org.glassfish.jersey.server.ContainerRequest;
+import org.glassfish.jersey.server.ContainerResponse;
+import org.glassfish.jersey.server.monitoring.ApplicationEvent;
+import org.glassfish.jersey.server.monitoring.ApplicationEventListener;
+import org.glassfish.jersey.server.monitoring.RequestEvent;
+import org.glassfish.jersey.server.monitoring.RequestEventListener;
+
+import io.opentracing.Span;
+import io.opentracing.SpanContext;
+import io.opentracing.Tracer;
+import io.opentracing.propagation.Format;
+import io.opentracing.propagation.TextMapExtractAdapter;
+import io.opentracing.tag.Tags;
+import io.opentracing.util.GlobalTracer;
+
+/**
+ * Application event listener responsible for creating and propagating server-side request {@link io.opentracing.Span}.
+ *
+ * @author Adam Lindenthal (adam.lindenthal at oracle.com)
+ * @since 2.26
+ */
+class OpenTracingApplicationEventListener implements ApplicationEventListener {
+    private final Tracer globalTracer = GlobalTracer.get();
+    private final OpenTracingFeature.Verbosity verbosity;
+
+    /**
+     * Creates event listener instance with given {@link org.glassfish.jersey.opentracing.OpenTracingFeature.Verbosity}.
+     *
+     * @param verbosity desired verbosity level
+     */
+    public OpenTracingApplicationEventListener(OpenTracingFeature.Verbosity verbosity) {
+        this.verbosity = verbosity;
+    }
+
+    @Override
+    public void onEvent(ApplicationEvent event) {
+        // we don't care about the server lifecycle
+    }
+
+    @Override
+    public RequestEventListener onRequest(RequestEvent requestEvent) {
+        if (requestEvent.getType() == RequestEvent.Type.START) {
+            Span requestSpan = handleRequestStart(requestEvent.getContainerRequest());
+            return new OpenTracingRequestEventListener(requestSpan);
+        }
+        return null;
+    }
+
+    private Span handleRequestStart(ContainerRequest request) {
+
+        final Map<String, String> mappedHeaders = request
+                .getHeaders()
+                .entrySet()
+                .stream()
+                .collect(Collectors.toMap(
+                        Map.Entry::getKey,
+                        (entry) -> OpenTracingUtils.formatList(entry.getValue())));
+
+        final SpanContext extractedContext =
+                globalTracer.extract(Format.Builtin.HTTP_HEADERS, new TextMapExtractAdapter(mappedHeaders));
+
+        Tracer.SpanBuilder spanBuilder = globalTracer
+                .buildSpan(OpenTracingFeature.DEFAULT_REQUEST_SPAN_NAME)
+                .withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_SERVER)
+                .withTag(Tags.HTTP_METHOD.getKey(), request.getMethod())
+                .withTag(Tags.HTTP_URL.getKey(), request.getRequestUri().toASCIIString())
+                .withTag(LocalizationMessages.OPENTRACING_TAG_REQUEST_HEADERS(),
+                        OpenTracingUtils.headersAsString(request.getHeaders()))
+                .withTag(LocalizationMessages.OPENTRACING_TAG_HAS_REQUEST_ENTITY(), request.hasEntity());
+
+        if (extractedContext != null) {
+            spanBuilder = spanBuilder.asChildOf(extractedContext);
+        }
+
+        final Span span = spanBuilder.startManual();
+        request.setProperty(OpenTracingFeature.SPAN_CONTEXT_PROPERTY, span);
+        span.log(LocalizationMessages.OPENTRACING_LOG_REQUEST_STARTED());
+        return span;
+    }
+
+    class OpenTracingRequestEventListener implements RequestEventListener {
+        private Span requestSpan;
+        private Span resourceSpan = null;
+
+        OpenTracingRequestEventListener(final Span requestSpan) {
+            this.requestSpan = requestSpan;
+        }
+
+        @Override
+        public void onEvent(RequestEvent event) {
+
+            switch (event.getType()) {
+                case MATCHING_START:
+                    logVerbose(LocalizationMessages.OPENTRACING_LOG_MATCHING_STARTED());
+                    break;
+
+                case LOCATOR_MATCHED:
+                    logVerbose(LocalizationMessages.OPENTRACING_LOG_LOCATOR_MATCHED(
+                            OpenTracingUtils.formatList(event.getUriInfo().getMatchedResourceLocators())));
+                    break;
+
+                case SUBRESOURCE_LOCATED:
+                    logVerbose(LocalizationMessages.OPENTRACING_LOG_SUBRESOURCE_LOCATED(
+                            OpenTracingUtils.formatList(event.getUriInfo().getLocatorSubResources())));
+                    break;
+
+
+                case REQUEST_MATCHED:
+                    logVerbose(LocalizationMessages.OPENTRACING_LOG_REQUEST_MATCHED(event.getUriInfo()
+                            .getMatchedResourceMethod()
+                            .getInvocable()
+                            .getDefinitionMethod()));
+                    log(LocalizationMessages.OPENTRACING_LOG_REQUEST_FILTERING_STARTED());
+                    break;
+
+                case REQUEST_FILTERED:
+                    List<ContainerRequestFilter> requestFilters = new ArrayList<>();
+                    event.getContainerRequestFilters().forEach(requestFilters::add);
+
+                    logVerbose(LocalizationMessages.OPENTRACING_LOG_REQUEST_FILTERING_FINISHED(requestFilters.size()));
+                    if (requestFilters.size() > 0) {
+                        log(LocalizationMessages.OPENTRACING_LOG_APPLIED_REQUEST_FILTERS(
+                                OpenTracingUtils.formatProviders(requestFilters)));
+                    }
+                    break;
+
+                case RESOURCE_METHOD_START:
+                    logVerbose(LocalizationMessages.OPENTRACING_LOG_RESOURCE_METHOD_STARTED(
+                            event.getUriInfo().getMatchedResourceMethod().getInvocable().getDefinitionMethod()));
+
+                    resourceSpan = globalTracer.buildSpan(OpenTracingFeature.DEFAULT_RESOURCE_SPAN_NAME)
+                                               .asChildOf(requestSpan)
+                                               .startManual();
+
+                    event.getContainerRequest().setProperty(OpenTracingFeature.SPAN_CONTEXT_PROPERTY, resourceSpan);
+                    break;
+
+                case RESOURCE_METHOD_FINISHED:
+                    log(LocalizationMessages.OPENTRACING_LOG_RESOURCE_METHOD_FINISHED());
+                    break;
+
+                case RESP_FILTERS_START:
+                    // this is the first event after resource method is guaranteed to have finished, even for asynchronous
+                    // processing; resourceSpan will be finished and the span in the context will be switched back to the
+                    // resource span before any further tracing can occur.
+                    event.getContainerRequest().setProperty(OpenTracingFeature.SPAN_CONTEXT_PROPERTY, requestSpan);
+                    resourceSpan.finish();
+                    logVerbose(LocalizationMessages.OPENTRACING_LOG_RESPONSE_FILTERING_STARTED());
+                    break;
+
+                case RESP_FILTERS_FINISHED:
+                    List<ContainerResponseFilter> responseFilters = new ArrayList<>();
+                    event.getContainerResponseFilters().forEach(responseFilters::add);
+                    logVerbose(LocalizationMessages.OPENTRACING_LOG_RESPONSE_FILTERING_FINISHED(responseFilters.size()));
+                    if (responseFilters.size() > 0) {
+                        log(LocalizationMessages.OPENTRACING_LOG_APPLIED_RESPONSE_FILTERS(
+                                OpenTracingUtils.formatProviders(responseFilters)));
+                    }
+                    break;
+
+                case ON_EXCEPTION:
+                    if (resourceSpan != null) {
+                        resourceSpan.setTag(Tags.ERROR.getKey(), true);
+                        resourceSpan.finish();
+                    }
+                    requestSpan.setTag(Tags.ERROR.getKey(), true);
+                    logError(event.getException());
+                    break;
+
+                case EXCEPTION_MAPPER_FOUND:
+                    log(LocalizationMessages.OPENTRACING_LOG_EXCEPTION_MAPPER_FOUND(
+                            event.getExceptionMapper().getClass().getName()));
+                    break;
+
+                case EXCEPTION_MAPPING_FINISHED:
+                    log(LocalizationMessages.OPENTRACING_LOG_EXCEPTION_MAPPING_FINISHED()
+                            + (event.isResponseSuccessfullyMapped()
+                            ? LocalizationMessages.OPENTRACING_LOG_EXCEPTION_MAPPING_SUCCESS()
+                            : LocalizationMessages.OPENTRACING_LOG_EXCEPTION_MAPPING_NOEXCEPTION_OR_FAILED()));
+
+                    break;
+
+
+                case FINISHED:
+                    if (requestSpan != null) {
+                        ContainerResponse response = event.getContainerResponse();
+                        if (response != null) {
+                            int status = response.getStatus();
+                            requestSpan
+                                    .setTag(Tags.HTTP_STATUS.getKey(), status)
+                                    .setTag(LocalizationMessages.OPENTRACING_TAG_HAS_RESPONSE_ENTITY(), response.hasEntity())
+                                    .setTag(LocalizationMessages.OPENTRACING_TAG_RESPONSE_LENGTH(), response.getLength());
+
+                            if (400 <= status) {
+                                requestSpan.setTag(Tags.ERROR.getKey(), true);
+                            }
+                        }
+                        requestSpan.finish();
+                    }
+                    break;
+            }
+        }
+
+        /**
+         * Adds a {@link OpenTracingFeature.Verbosity#TRACE}-level log entry into the request span.
+         * @param s log message
+         */
+        private void logVerbose(String s) {
+            log(OpenTracingFeature.Verbosity.TRACE, s);
+        }
+
+        /**
+         * Adds a {@link OpenTracingFeature.Verbosity#INFO}-level log entry into the request span.
+         * @param s log message
+         */
+        private void log(String s) {
+            log(OpenTracingFeature.Verbosity.INFO, s);
+        }
+
+        /**
+         * Adds a log entry with given {@link org.glassfish.jersey.opentracing.OpenTracingFeature.Verbosity}-level into the
+         * request span.
+         *
+         * @param level desired verbosity level
+         * @param s log message
+         */
+        private void log(OpenTracingFeature.Verbosity level, String s) {
+            if (level.ordinal() <= verbosity.ordinal()) {
+                requestSpan.log(s);
+            }
+        }
+
+        /**
+         * Adds an error log into the request span.
+         * @param t exception to be logged.
+         */
+        private void logError(final Throwable t) {
+            Map<String, Object> errorMap = new HashMap<>(2);
+            errorMap.put("event", "error");
+            errorMap.put("error.object", t);
+            requestSpan.log(errorMap);
+        }
+    }
+
+}
diff --git a/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingClientRequestFilter.java b/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingClientRequestFilter.java
new file mode 100644
index 0000000..7934488
--- /dev/null
+++ b/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingClientRequestFilter.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.opentracing;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import javax.ws.rs.client.ClientRequestContext;
+import javax.ws.rs.client.ClientRequestFilter;
+import javax.ws.rs.core.MediaType;
+
+import io.opentracing.Span;
+import io.opentracing.SpanContext;
+import io.opentracing.Tracer;
+import io.opentracing.propagation.Format;
+import io.opentracing.propagation.TextMapInjectAdapter;
+import io.opentracing.tag.Tags;
+import io.opentracing.util.GlobalTracer;
+
+/**
+ * Client-side request filter, that creates the client request {@code Span}.
+ * <p>
+ * Stores request-related metadata into the {@code Span} as {@code Tags}
+ * and {@link GlobalTracer#inject(SpanContext, Format, Object) injects} it into http headers.
+ *
+ * @author Adam Lindenthal (adam.lindenthal at oracle.com)
+ * @since 2.26
+ */
+class OpenTracingClientRequestFilter implements ClientRequestFilter {
+
+    @Override
+    public void filter(ClientRequestContext requestContext) throws IOException {
+        Tracer.SpanBuilder spanBuilder = GlobalTracer.get()
+                .buildSpan(LocalizationMessages.OPENTRACING_SPAN_PREFIX_CLIENT() + requestContext.getMethod())
+                .withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT)
+                .withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT)
+                .withTag(Tags.HTTP_URL.getKey(), requestContext.getUri().toASCIIString())
+                .withTag(Tags.HTTP_METHOD.getKey(), requestContext.getMethod())
+                .withTag(LocalizationMessages.OPENTRACING_TAG_HAS_REQUEST_ENTITY(), requestContext.hasEntity())
+                .withTag(LocalizationMessages.OPENTRACING_TAG_ACCEPTABLE_MEDIA_TYPES(), requestContext.getAcceptableMediaTypes()
+                        .stream()
+                        .map(MediaType::toString)
+                        .collect(Collectors.joining(", ")))
+                .withTag(LocalizationMessages.OPENTRACING_TAG_REQUEST_HEADERS(),
+                        OpenTracingUtils.headersAsString(requestContext.getHeaders()));
+
+        // if pre-stored "span" property is found, propagate the stored context
+        final Object property = requestContext.getProperty(OpenTracingFeature.SPAN_CONTEXT_PROPERTY);
+        if (property != null && property instanceof SpanContext) {
+            spanBuilder = spanBuilder.asChildOf((SpanContext) property);
+        }
+        Span span = spanBuilder.startManual();
+
+        requestContext.setProperty(OpenTracingFeature.SPAN_CONTEXT_PROPERTY, span);
+        Map<String, String> addedHeaders = new HashMap<>();
+        GlobalTracer.get().inject(span.context(), Format.Builtin.HTTP_HEADERS, new TextMapInjectAdapter(addedHeaders));
+        addedHeaders.forEach((key, value) -> requestContext.getHeaders().add(key, value));
+    }
+}
diff --git a/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingClientResponseFilter.java b/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingClientResponseFilter.java
new file mode 100644
index 0000000..0dae48f
--- /dev/null
+++ b/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingClientResponseFilter.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.opentracing;
+
+import java.io.IOException;
+
+import javax.ws.rs.client.ClientRequestContext;
+import javax.ws.rs.client.ClientResponseContext;
+import javax.ws.rs.client.ClientResponseFilter;
+
+import io.opentracing.Span;
+import io.opentracing.tag.Tags;
+
+/**
+ * Retrieves stored span from the {@link ClientRequestContext} and adds response details to the tracing info.
+ *
+ * @author Adam Lindenthal (adam.lindenthal at oracle.com)
+ * @since 2.26
+ */
+public class OpenTracingClientResponseFilter implements ClientResponseFilter {
+
+    @Override
+    public void filter(ClientRequestContext requestContext, ClientResponseContext responseContext) throws IOException {
+        final Object spanProperty = requestContext.getProperty(OpenTracingFeature.SPAN_CONTEXT_PROPERTY);
+        if (spanProperty != null && spanProperty instanceof Span) {
+            ((Span) spanProperty)
+                    .setTag(Tags.HTTP_STATUS.getKey(), responseContext.getStatus())
+                    .setTag(LocalizationMessages.OPENTRACING_TAG_HAS_RESPONSE_ENTITY(), responseContext.hasEntity())
+                    .setTag(LocalizationMessages.OPENTRACING_TAG_RESPONSE_LENGTH(), responseContext.getLength())
+                    .setTag(LocalizationMessages.OPENTRACING_TAG_RESPONSE_HEADERS(),
+                            OpenTracingUtils.headersAsString(responseContext.getHeaders()))
+                    .finish();
+        }
+    }
+}
diff --git a/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingFeature.java b/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingFeature.java
new file mode 100644
index 0000000..6afb1f9
--- /dev/null
+++ b/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingFeature.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.opentracing;
+
+import java.util.logging.Logger;
+
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.core.Feature;
+import javax.ws.rs.core.FeatureContext;
+
+import org.glassfish.jersey.Beta;
+
+import io.opentracing.util.GlobalTracer;
+
+/**
+ * A feature that enables OpenTracing support on server and client.
+ *
+ * @author Adam Lindenthal (adam.lindenthal at oracle.com)
+ * @since 2.26
+ */
+@Beta
+public class OpenTracingFeature implements Feature {
+    private static final Logger LOGGER = Logger.getLogger(OpenTracingFeature.class.getName());
+    private final Verbosity verbosity;
+
+    /**
+     * Creates feature instance with default ({@link Verbosity#INFO} verbosity level.
+     */
+    public OpenTracingFeature() {
+        verbosity = Verbosity.INFO;
+    }
+
+    /**
+     * Creates feature instance with given ({@link Verbosity} level.
+     * @param verbosity desired level of logging verbosity
+     */
+    public OpenTracingFeature(Verbosity verbosity) {
+        this.verbosity = verbosity;
+    }
+
+    /**
+     * Stored span's {@link ContainerRequestContext} property key.
+     */
+    public static final String SPAN_CONTEXT_PROPERTY = "span";
+
+    /**
+     * Default resource span name.
+     */
+    public static final String DEFAULT_RESOURCE_SPAN_NAME = "jersey-resource";
+
+    /**
+     * Default child span name.
+     */
+    public static final String DEFAULT_CHILD_SPAN_NAME = "jersey-resource-app";
+
+    /**
+     * Default request "root" span name.
+     */
+    public static final String DEFAULT_REQUEST_SPAN_NAME = "jersey-server";
+
+    @Override
+    public boolean configure(FeatureContext context) {
+        if (!GlobalTracer.isRegistered()) {
+            LOGGER.warning(LocalizationMessages.OPENTRACING_TRACER_NOT_REGISTERED());
+        }
+
+        switch (context.getConfiguration().getRuntimeType()) {
+            case CLIENT:
+                context.register(OpenTracingClientRequestFilter.class).register(OpenTracingClientResponseFilter.class);
+                break;
+            case SERVER:
+                context.register(new OpenTracingApplicationEventListener(verbosity));
+        }
+        return true;
+    }
+
+    /**
+     * OpenTracing Jersey event logging verbosity.
+     */
+    public enum Verbosity {
+        /**
+         * Only logs basic Jersey processing related events.
+         */
+        INFO,
+
+        /**
+         * Logs more fine grained events related to Jersey processing.
+         */
+        TRACE
+    }
+
+}
diff --git a/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingUtils.java b/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingUtils.java
new file mode 100644
index 0000000..4bc3ad0
--- /dev/null
+++ b/incubator/open-tracing/src/main/java/org/glassfish/jersey/opentracing/OpenTracingUtils.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.opentracing;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.core.MultivaluedMap;
+
+import io.opentracing.Span;
+import io.opentracing.Tracer;
+import io.opentracing.util.GlobalTracer;
+
+/**
+ * Utility methods for Jersey OpenTracing integration.
+ *
+ * @author Adam Lindenthal (adam.lindenthal at oracle.com)
+ * @since 2.26
+ */
+public class OpenTracingUtils {
+
+    private OpenTracingUtils() {
+    }
+
+    /**
+     * Resolve resource-level span.
+     * <p>
+     * If open tracing is enabled and {@link GlobalTracer} is registered, resource-level span should be stored in the
+     * {@link OpenTracingFeature#SPAN_CONTEXT_PROPERTY}. This span is resolved and returned as an {@link Optional}.
+     *
+     * @param context {@link ContainerRequestContext} instance, can be obtained via {@code @Context} injection
+     * @return {@link Optional} of the resolved span, if found; empty optional if not
+     */
+    public static Optional<Span> getRequestSpan(final ContainerRequestContext context) {
+        if (context != null) {
+            final Object spanProperty = context.getProperty(OpenTracingFeature.SPAN_CONTEXT_PROPERTY);
+            if (spanProperty != null && spanProperty instanceof Span) {
+                return Optional.of((Span) spanProperty);
+            }
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Create and start ad-hoc custom span with the default name as a child span of the request span (if available).
+     *
+     * @param context {@link ContainerRequestContext} instance, can be obtained via {@code @Context} injection
+     * @return If parent span ("request span") instance is stored in the {@code ContainerRequestContext}, new span is created
+     * as a child span of the found span. If no parent span found, new "root" span is created. In both cases, the returned span
+     * is already started. In order to successfully store the tracing, {@link Span#finish()} needs to be invoked explicitly,
+     * after the traced code finishes.
+     */
+    public static Span getRequestChildSpan(final ContainerRequestContext context) {
+        return getRequestChildSpan(context, OpenTracingFeature.DEFAULT_CHILD_SPAN_NAME);
+    }
+
+    /**
+     * Create and start ad-hoc custom span with a custom name as a child span of the request span (if available).
+     *
+     * @param context  {@link ContainerRequestContext} instance, can be obtained via {@code @Context} injection
+     * @param spanName name to be used for the created span
+     * @return If parent span ("request span") instance is stored in the {@code ContainerRequestContext}, new span is created
+     * as a child span of the found span. If no parent span found, new "root" span is created. In both cases, the returned span
+     * is already started. In order to successfully store the tracing, {@link Span#finish()} needs to be invoked explicitly,
+     * after the traced code finishes.
+     */
+    public static Span getRequestChildSpan(final ContainerRequestContext context, final String spanName) {
+        Tracer.SpanBuilder spanBuilder = GlobalTracer.get().buildSpan(spanName);
+        if (context != null) {
+            final Object spanProperty = context.getProperty(OpenTracingFeature.SPAN_CONTEXT_PROPERTY);
+            if (spanProperty != null && spanProperty instanceof Span) {
+                spanBuilder = spanBuilder.asChildOf((Span) spanProperty);
+            }
+        }
+        return spanBuilder.startManual();
+    }
+
+    /**
+     * Convert request/response headers from {@link MultivaluedMap} into printable form.
+     *
+     * @param headers multi-valued map of request or response headers
+     * @return {@code String} representation, e.g. "[header1=foo]; [header2=bar, baz]"
+     */
+    static String headersAsString(final MultivaluedMap<String, ?> headers) {
+        return headers.entrySet()
+                .stream()
+                .map((entry) -> "["
+                        + entry.getKey() + "="
+                        + entry.getValue()
+                        .stream()
+                        .map(Object::toString)
+                        .collect(Collectors.joining(", "))
+                        + "]")
+                .collect(Collectors.joining("; "));
+    }
+
+    static String formatList(List<?> list) {
+        return list.stream().map(Object::toString).collect(Collectors.joining(", "));
+    }
+
+    static String formatProviders(Iterable<?> providers) {
+        return StreamSupport.stream(providers.spliterator(), false)
+                .map((provider) -> provider.getClass().getName())
+                .collect(Collectors.joining(", "));
+    }
+}
diff --git a/incubator/open-tracing/src/main/resources/org/glassfish/jersey/opentracing/localization.properties b/incubator/open-tracing/src/main/resources/org/glassfish/jersey/opentracing/localization.properties
new file mode 100644
index 0000000..67f8508
--- /dev/null
+++ b/incubator/open-tracing/src/main/resources/org/glassfish/jersey/opentracing/localization.properties
@@ -0,0 +1,44 @@
+#
+# Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+opentracing.tracer.not.registered=OpenTracing feature is enabled, but no Tracer has been registered. Default no-op tracer will \
+  be used.
+opentracing.log.request.started=Request started.
+opentracing.log.matching.started=Resource matching started.
+opentracing.log.request.matched=Request matched, method: {0}
+opentracing.log.locator.matched=Locator matched. Matched locators: {0}
+opentracing.log.subresource.located=Subresource located: {0}
+opentracing.log.request.filtering.started=Request filtering started.
+opentracing.log.request.filtering.finished=Request filtering finished, {0} filter(s) applied.
+opentracing.log.applied.request.filters=Applied request filters: {0}.
+opentracing.log.resource.method.started=Resource method {0} started.
+opentracing.log.response.filtering.started=Response filtering started.
+opentracing.log.resource.method.finished=Resource method finished.
+opentracing.log.response.filtering.finished=Response filtering finished, {0} filter(s) applied.
+opentracing.log.applied.response.filters=Applied reqsponse filters: {0}.
+opentracing.log.exception=Exception while processing the request: {0}.
+opentracing.log.exception.mapper.found=Exception mapper found: {0}.
+opentracing.log.exception.mapping.finished=Exception mapping finished: 
+opentracing.log.exception.mapping.success=successfully mapped
+opentracing.log.exception.mapping.noexception.or.failed=no exception or mapping failed.
+opentracing.tag.request.headers=requestHeaders
+opentracing.tag.response.headers=responseHeaders
+opentracing.tag.has.request.entity=hasRequestEntity
+opentracing.tag.has.response.entity=hasResponseEntity
+opentracing.tag.response.length=responseLength
+opentracing.tag.acceptable.media.types=acceptableMediaTypes
+opentracing.span.prefix.client=jersey-client-
+
diff --git a/incubator/pom.xml b/incubator/pom.xml
new file mode 100644
index 0000000..484edcb
--- /dev/null
+++ b/incubator/pom.xml
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
+
+    This program and the accompanying materials are made available under the
+    terms of the Eclipse Public License v. 2.0, which is available at
+    http://www.eclipse.org/legal/epl-2.0.
+
+    This Source Code may also be made available under the following Secondary
+    Licenses when the conditions for such availability set forth in the
+    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+    version 2 with the GNU Classpath Exception, which is available at
+    https://www.gnu.org/software/classpath/license.html.
+
+    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.glassfish.jersey</groupId>
+        <artifactId>project</artifactId>
+        <version>2.28-SNAPSHOT</version>
+    </parent>
+
+    <groupId>org.glassfish.jersey.incubator</groupId>
+    <artifactId>project</artifactId>
+    <packaging>pom</packaging>
+    <name>jersey-incubator</name>
+
+    <description>
+        Jersey incubator for experimental modules that are in a prototyping or research stage,
+        not ready to be released as part of Jersey (yet).
+    </description>
+
+    <modules>
+        <module>declarative-linking</module>
+        <module>gae-integration</module>
+        <!--<module>html-json</module>-->
+        <module>kryo</module>
+        <module>open-tracing</module>
+    </modules>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.glassfish.jersey.inject</groupId>
+            <artifactId>jersey-hk2</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>