Example of constructor interception with Jersey/HK2

ConstructorInterceptExample.java

import org.aopalliance.intercept.ConstructorInterceptor;
import org.aopalliance.intercept.ConstructorInvocation;
import org.aopalliance.intercept.MethodInterceptor;
import org.glassfish.hk2.api.Filter;
import org.glassfish.hk2.api.InterceptionService;
import org.glassfish.hk2.utilities.BuilderHelper;
import org.glassfish.hk2.utilities.binding.AbstractBinder;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.junit.Test;

import javax.inject.Singleton;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.core.Response;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Run like any other JUnit test. Only one required dependency:
 *
 * <dependency>
 *    <groupId>org.glassfish.jersey.test-framework.providers</groupId>
 *    <artifactId>jersey-test-framework-provider-grizzly2</artifactId>
 *    <version>${jersey2.version}</version>
 * </dependency>
 *
 * @author Paul Samsotha.
 */
public class ConstructorInterceptExample extends JerseyTest {


    public static class LoggingConstructorInterceptor implements ConstructorInterceptor {

        private static final Logger LOG
                = Logger.getLogger(LoggingConstructorInterceptor.class.getName());

        @Override
        public Object construct(ConstructorInvocation invocation) throws Throwable {
            Constructor ctor = invocation.getConstructor();
            LOG.log(Level.INFO, "Creating: {0}", ctor.getDeclaringClass().getName());

            // returned instance from constructor invocation.
            Object instance = invocation.proceed();
            LOG.log(Level.INFO, "Created Instance: {0}", instance.toString());

            return instance;
        }
    }

    public static class PathInterceptionService implements InterceptionService {

        private static final ConstructorInterceptor CTOR_INTERCEPTOR
                = new LoggingConstructorInterceptor();
        private final static List<ConstructorInterceptor> CTOR_LIST
                = Collections.singletonList(CTOR_INTERCEPTOR);

        @Override
        public Filter getDescriptorFilter() {
            return BuilderHelper.allFilter();
        }

        @Override
        public List<MethodInterceptor> getMethodInterceptors(Method method) {
            return null;
        }

        @Override
        public List<ConstructorInterceptor> getConstructorInterceptors(Constructor<?> constructor) {
            if (constructor.getDeclaringClass().isAnnotationPresent(Path.class)) {
                return CTOR_LIST;
            }
            return null;
        }
    }

    @Override
    public ResourceConfig configure() {
        return new ResourceConfig()
                .register(TestResource.class)
                .register(new AbstractBinder(){
                    @Override
                    public void configure() {
                        bind(PathInterceptionService.class)
                                .to(InterceptionService.class)
                                .in(Singleton.class);
                        bind(LoggingConstructorInterceptor.class)
                                .to(ConstructorInterceptor.class)
                                .in(Singleton.class);
                    }
                });
    }


    @Path("test")
    public static class TestResource {
        @GET
        public String get() {
            return "Hello HK2 AOP";
        }
    }

    @Test
    public void doit() {
        final Response response = target("test")
                .request().get();
        System.out.println(response.readEntity(String.class));
    }
}