Java 类javax.ws.rs.core.FeatureContext 实例源码

@Override
public boolean configure(FeatureContext context) {

    context.register(new AbstractBinder() {

        @Override
        protected void configure() {

            Injector injector = ClientGuiceBridgeFeature.getInjector(context.getConfiguration());
            ClientGuiceInjectInjector injectInjector = new ClientGuiceInjectInjector(injector);

            bind(injectInjector).to(new TypeLiteral<InjectionResolver<com.google.inject.Inject>>() {
            });
        }
    });

    return true;
}

public boolean configure(final FeatureContext context) {
    final Configuration config = context.getConfiguration();
    final String jsonFeature = CommonProperties.getValue(config.getProperties(), config.getRuntimeType(), InternalProperties.JSON_FEATURE, JSON_FEATURE,
            String.class);
    // Other JSON providers registered.
    if (!JSON_FEATURE.equalsIgnoreCase(jsonFeature)) {
        return false;
    }
    // Disable other JSON providers.
    context.property(PropertiesHelper.getPropertyNameForRuntime(InternalProperties.JSON_FEATURE, config.getRuntimeType()), JSON_FEATURE);
    // Register FastJson.
    if (!config.isRegistered(FastJsonProvider.class)) {
        //DisableCircularReferenceDetect
        FastJsonProvider fastJsonProvider = new FastJsonProvider();
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        //fastJsonConfig.setSerializerFeatures(SerializerFeature.DisableCircularReferenceDetect,SerializerFeature.BrowserSecure);

        fastJsonConfig.setSerializerFeatures(SerializerFeature.DisableCircularReferenceDetect);

        fastJsonProvider.setFastJsonConfig(fastJsonConfig);

        context.register(fastJsonProvider, MessageBodyReader.class, MessageBodyWriter.class);
    }
    return true;
}

@Override
public boolean configure(final FeatureContext featureContext) {
    final UserRepository userRepo = CDI.current().select(UserRepository.class).get();
    final Authenticator<String, User> authenticator = new GoogleAuthenticator(
            authConfig.getClientId(), userRepo, authConfig.getHostedDomain()
    );

    final Authenticator<String, User> cachingAuthenticator = new CachingAuthenticator<>(
            metricRegistry, authenticator, authConfig.getAuthenticationCachePolicy()
    );

    featureContext.register(new AuthDynamicFeature(
            new OAuthCredentialAuthFilter.Builder<User>()
            .setAuthenticator(cachingAuthenticator)
            .setPrefix("Bearer")
            .buildAuthFilter()));
    featureContext.register(new AuthValueFactoryProvider.Binder<>(User.class));

    return true;
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {

    List<Annotation> authzSpecs = new ArrayList<>();

    Annotation classAuthzSpec =
        resourceInfo.getResourceClass().getAnnotation(AppkeyAnnotation.class);
    Annotation methodAuthzSpec =
        resourceInfo.getResourceMethod().getAnnotation(AppkeyAnnotation.class);

    if (classAuthzSpec != null)
        authzSpecs.add(classAuthzSpec);
    if (methodAuthzSpec != null)
        authzSpecs.add(methodAuthzSpec);

    if (!authzSpecs.isEmpty()) {
        context.register(AppkeyFilter.class);
    }
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {

    List<Annotation> authzSpecs = new ArrayList<>();

    Annotation classAuthzSpec =
        resourceInfo.getResourceClass().getAnnotation(AuthAnnotation.class);
    Annotation methodAuthzSpec =
        resourceInfo.getResourceMethod().getAnnotation(AuthAnnotation.class);

    if (classAuthzSpec != null)
        authzSpecs.add(classAuthzSpec);
    if (methodAuthzSpec != null)
        authzSpecs.add(methodAuthzSpec);

    if (!authzSpecs.isEmpty()) {
        // 需要拦截的api
        context.register(AuthorizationFilter.class);
    }
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {
    CacheFor cc = resourceInfo.getResourceClass().getAnnotation(CacheFor.class);
    CacheFor mcc = resourceInfo.getResourceMethod().getAnnotation(CacheFor.class);
    if( mcc!=null ) {
        cc = mcc;
    }
    if (cc!=null) {
        if( cc.value() == 0 ) {
            context.register(NoCacheFilter.class);
        } else if( cc.value() > 0 ) {
            context.register(new CacheFilter("max-age= " + cc.unit().toSeconds(cc.value())));
        }
    } else {
        context.register(NoCacheFilter.class);
    }
}

@Override
public boolean configure(FeatureContext context) {
    if (context.getConfiguration().isEnabled(this.getClass())) {
        return false;
    }

    switch (context.getConfiguration().getRuntimeType()) {
    case SERVER:
        context.register(new ServerFilter(tracer));
        break;
    case CLIENT:
        context.register(new ClientFilter(tracer));
        break;
    default:
        LOGGER.error("Unknown runtime ({}), not registering Haystack feature", context.getConfiguration().getRuntimeType());
        return false;
    }
    return true;
}

@Override
public boolean configure(FeatureContext context) {
    if (context.getConfiguration().getProperties().containsKey(JacksonFeature.JAXRS_DISABLE_JACKSON_AUTO_CONFIG)) {
        LOGGER.debug(() -> "Skip JacksonJsonProvider registration, ["
                + JacksonFeature.JAXRS_DISABLE_JACKSON_AUTO_CONFIG + "] property detected");
        return false;
    }

    if (!context.getConfiguration().isRegistered(JacksonJsonPropertyBoxProvider.class)) {
        LOGGER.debug(() -> "<Runtime: " + context.getConfiguration().getRuntimeType() + "> Registering provider ["
                + JacksonJsonPropertyBoxProvider.class.getName() + "]");
        context.register(JacksonJsonPropertyBoxProvider.class);
    }
    return true;

}

/**
 * Register a Jersey JSON provider feature only if another JSON provider is not already registered, checking
 * {@link #JERSEY_JSON_PROVIDER_PROPERTY} property value.
 * @param context Feature context
 * @param feature Feature to register
 * @param featureName Feature name to register
 * @return <code>true</code> if feature was registered, <code>false</code> otherwise
 */
private static boolean registerJerseyJsonFeature(FeatureContext context, Class<? extends Feature> feature,
        String featureName) {
    final Configuration config = context.getConfiguration();

    final String jsonFeature = CommonProperties.getValue(config.getProperties(), config.getRuntimeType(),
            JERSEY_JSON_PROVIDER_PROPERTY, featureName, String.class);
    if (!featureName.equalsIgnoreCase(jsonFeature)) {
        // Other JSON providers registered
        return false;
    }
    // Disable other JSON providers
    context.property(
            PropertiesHelper.getPropertyNameForRuntime(JERSEY_JSON_PROVIDER_PROPERTY, config.getRuntimeType()),
            featureName);
    // Register
    if (!config.isRegistered(feature)) {
        context.register(feature);
    }
    return true;
}

@Override
public boolean configure(final FeatureContext context) {
    PropertiesProvider propertiesProvider = new PropertiesProvider() {

        @Override
        public String getProperty(String key) {
            return (String) context.getConfiguration().getProperty(key);
        }
    };

    boot.setPropertiesProvider(propertiesProvider);
    boot.addModule(new JaxrsModule(securityContext));
    boot.boot();

    parameterProviderRegistry = buildParameterProviderRegistry();

    CrnkFilter crnkFilter = createCrnkFilter();
    context.register(crnkFilter);

    registerActionRepositories(context, boot);

    return true;
}

@Override
public boolean configure(FeatureContext context) {
    // limit to SERVER runtime
    if (RuntimeType.SERVER == context.getConfiguration().getRuntimeType()) {

        // check disabled
        if (context.getConfiguration().getProperties().containsKey(DISABLE_AUTHENTICATION)) {
            LOGGER.debug(() -> "Skip AuthenticationFeature registration, [" + DISABLE_AUTHENTICATION
                    + "] property detected");
            return false;
        }

        if (!context.getConfiguration().isRegistered(AuthenticationDynamicFeature.class)) {
            context.register(AuthenticationDynamicFeature.class);
        }
        return true;
    }
    return false;
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {
    // 获取资源方法
    Method resourceMethod = resourceInfo.getResourceMethod();

    if (resourceMethod != null) {

        // 获取FormatJson注解
        ResponseFormat formatJson = resourceMethod.getAnnotation(ResponseFormat.class);

        if (formatJson == null || formatJson.type().equals(FormatType.JSON)) {
            context.register(DefaultWebFilter.class);
        }

    }
}

public TestChain(TestServiceRunnerBase serviceRunner) {
    this.actions = ImmutableList.of();
    this.serviceLocator = new ServiceLocatorHolder();

    Feature lifecycleListener = new Feature() {
        @Inject
        public void setServiceLocator(ServiceLocator s) {
            serviceLocator.set(s);
        }

        @Override
        public boolean configure(FeatureContext context) {
            return false;
        }
    };
    this.serviceRunner = serviceRunner
            .serviceConfig(serviceRunner.getServiceConfig()
                    .registerInstance(lifecycleListener)
            );
}

@Override
public boolean configure(FeatureContext context) {
    boolean modified = false;
    AccessControlAllowOriginRequestFilter accessControlAllowOriginRequestFilter = new AccessControlAllowOriginRequestFilter(
            originFilter);
    if (!context.getConfiguration().isRegistered(accessControlAllowOriginRequestFilter)) {
        context.register(accessControlAllowOriginRequestFilter);
        modified = true;
    }

    AccessControlAllowOriginResponseFilter accessControlAllowOriginResponseFilter = new AccessControlAllowOriginResponseFilter(
            originFilter);
    if (!context.getConfiguration().isRegistered(accessControlAllowOriginResponseFilter)) {
        context.register(accessControlAllowOriginResponseFilter);
        modified = true;
    }

    SimpleAccessControlAllowHeaderFilter simpleAccessControlAllowHeaderFilter = new SimpleAccessControlAllowHeaderFilter(
            allowedHeaders);
    if (!context.getConfiguration().isRegistered(simpleAccessControlAllowHeaderFilter)) {
        context.register(simpleAccessControlAllowHeaderFilter);
        modified = true;
    }
    return modified;
}

@Override
public boolean configure(FeatureContext context) {
  Configuration configuration = context.getConfiguration();
  Boolean enabled = PropertyHelper.getProperty(configuration, RestServerV2.FIRST_TIME_API_ENABLE);
  Boolean testApiEnabled = PropertyHelper.getProperty(configuration, RestServerV2.TEST_API_ENABLE);

  // Default is not enabled
  if (enabled == null || !enabled) {
    return false;
  }

  boolean allowTestApis = testApiEnabled != null && testApiEnabled;

  // this is handled separately from firstTimeApi because we may enable the api only on master
  // but still register the filer on all nodes
  context.register(BootstrapResource.class);
  if (allowTestApis) {
    context.register(NoUserTestFilter.class);
  } else {
    context.register(NoUserFilter.class);
  }

  return true;
}

@Override
public boolean configure(FeatureContext context) {
  Configuration configuration = context.getConfiguration();
  Boolean enabled = PropertyHelper.getProperty(configuration, RestServerV2.TEST_API_ENABLE);

  // Default is not enabled
  if (enabled == null || !enabled) {
    return false;
  }

  for (Class<?> resource : scanResult.getAnnotatedClasses(RestResourceUsedForTesting.class)) {
    context.register(resource);
  }

  return true;
}

@Override
public boolean configure(FeatureContext context) {
  final Configuration configuration = context.getConfiguration();

  Boolean disabled = PropertyHelper.getProperty(configuration, RestServerV2.DAC_AUTH_FILTER_DISABLE);
  // Default is not disabled
  if (disabled != null && disabled) {
    return false;
  }

  context.register(DACAuthFilter.class);
  if (!configuration.isRegistered(RolesAllowedDynamicFeature.class)) {
    context.register(RolesAllowedDynamicFeature.class);
  }
  return true;
}

public boolean configure(final FeatureContext context) {
    final Configuration config = context.getConfiguration();
    final String jsonFeature = CommonProperties.getValue(config.getProperties(), config.getRuntimeType(), InternalProperties.JSON_FEATURE, JSON_FEATURE,
            String.class);
    // Other JSON providers registered.
    if (!JSON_FEATURE.equalsIgnoreCase(jsonFeature)) {
        return false;
    }
    // Disable other JSON providers.
    context.property(PropertiesHelper.getPropertyNameForRuntime(InternalProperties.JSON_FEATURE, config.getRuntimeType()), JSON_FEATURE);
    // Register FastJson.
    if (!config.isRegistered(FastJsonProvider.class)) {
        context.register(FastJsonProvider.class, MessageBodyReader.class, MessageBodyWriter.class);
    }
    return true;
}

@Override
public void configure(FeatureContext context) {
    final int priorityInc = 3000;

    // Jersey MOXY provider have higher priority(7000), so we need set higher than it
    int priority = Priorities.USER + priorityInc;
    Configuration config = context.getConfiguration();

    if (!config.isRegistered(ParsecValidationExceptionMapper.class)) {
        context.register(ParsecValidationExceptionMapper.class, priority);
    }
    if (!config.isRegistered(ValidationConfigurationContextResolver.class)) {
        context.register(ValidationConfigurationContextResolver.class, priority);
    }
    if (!config.isRegistered(ParsecMoxyProvider.class)) {
        context.register(ParsecMoxyProvider.class, priority);
    }
    if (!config.isRegistered(JaxbExceptionMapper.class)) {
        context.register(JaxbExceptionMapper.class, priority);
    }
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {
    Class<?> resourceClass = resourceInfo.getResourceClass();
    Method resourceMethod = resourceInfo.getResourceMethod();
    if (isStaticContent(resourceClass, resourceMethod)) {
        // class or method is annotated with MCRStaticContent
        //   -> do not register any filter
        return;
    }
    String packageName = resourceClass.getPackage().getName();
    if (getPackages().contains(packageName)) {
        registerTransactionFilter(context);
        registerSessionHookFilter(context);
        registerAccessFilter(context, resourceClass, resourceMethod);
    }
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext featureContext) {

    AnnotatedMethod am = new AnnotatedMethod(resourceInfo.getResourceMethod());

    RequireBasicAuth requireBasicAuth = null;
    if (am.isAnnotationPresent(RequireBasicAuth.class)) {
        requireBasicAuth = am.getAnnotation(RequireBasicAuth.class);
    }
    else {
        requireBasicAuth = resourceInfo.getResourceClass().getAnnotation(RequireBasicAuth.class);
    }

    if (requireBasicAuth != null) {
        featureContext.register(new BasicAuthKarafSecurityRequestFilter(requireBasicAuth.limitToGroups(), requireBasicAuth.limitToRoles(), requireBasicAuth.karafRealm(), requireBasicAuth.requiresSecure(), requireBasicAuth.httpRealm()));
    }
}

@Override
public boolean configure(FeatureContext context) {
    Configuration configuration = context.getConfiguration();
    if (!configuration.isRegistered(ConfigPropertyResolver.class)) {
        LOGGER.debug("Register ConfigPropertyFeature");
        context.register(ConfigPropertyResolver.class);
        context.register(new AbstractBinder() {
            @Override
            protected void configure() {
                bind(ConfigPropertyResolver.class)
                        .to(new TypeLiteral<InjectionResolver<ConfigProperty>>() {})
                        .in(Singleton.class);
            }
        });
    }
    return true;
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {
    final AnnotatedMethod am = new AnnotatedMethod(resourceInfo.getResourceMethod());
    final Annotation[][] parameterAnnotations = am.getParameterAnnotations();
    //@DenyAll shouldn't be attached to classes
    final boolean annotationOnClass = (resourceInfo.getResourceClass().getAnnotation(RolesAllowed.class) != null) ||
            (resourceInfo.getResourceClass().getAnnotation(PermitAll.class) != null);
    final boolean annotationOnMethod = am.isAnnotationPresent(RolesAllowed.class) || am.isAnnotationPresent(DenyAll.class) ||
            am.isAnnotationPresent(PermitAll.class);

    if (annotationOnClass || annotationOnMethod) {
        context.register(filterClass);
    } else {
        for (Annotation[] annotations : parameterAnnotations) {
            for (Annotation annotation : annotations) {
                if (annotation instanceof Auth) {
                    context.register(filterClass);
                    return;
                }
            }
        }
    }
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {
    // 获取资源方法
    Method resourceMethod = resourceInfo.getResourceMethod();

    if (resourceMethod != null) {

        // 获取FormatJson注解
        ResponseFormat formatJson = resourceMethod.getAnnotation(ResponseFormat.class);

        if(formatJson == null || formatJson.type().equals(FormatType.JSON)){
            context.register(DefaultWebFilter.class);
        }

    }
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {
    // TODO why it is called twice for the same endpoint
    if (!tracingDisabled(resourceInfo) && builder.allTraced) {
        log(resourceInfo);
        context.register(new ServerTracingFilter(
            builder.tracer,
            operationName(resourceInfo),
            builder.spanDecorators,
            builder.operationNameBuilder.build(resourceInfo.getResourceClass(), resourceInfo.getResourceMethod()),
            builder.skipPattern != null ? Pattern.compile(builder.skipPattern) : null),
            builder.priority);

        if (builder.traceSerialization) {
            context.register(new ServerTracingInterceptor(builder.tracer,
                builder.serializationSpanDecorators), builder.serializationPriority);
        }
    }
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {
    Trace annotation = resourceInfo.getResourceMethod().getAnnotation(Trace.class);
    String operationName = this.operationName;
    if (annotation != null) {
        if (!annotation.operationName().equals("")) {
            operationName = annotation.operationName();
        }
        context.register(new ServerRequestTracingFilter(this.tracer, operationName,
            this.tracedAttributes, this.tracedProperties, this.decorator));
        context.register(new ServerResponseTracingFilter(this.tracer));  
    } else {
        if (traceAll) {
            context.register(new ServerRequestTracingFilter(this.tracer, operationName,
                this.tracedAttributes, this.tracedProperties, this.decorator));
            context.register(new ServerResponseTracingFilter(this.tracer));
        } 
    }
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {
    CacheFor cc = resourceInfo.getResourceClass().getAnnotation(CacheFor.class);
    CacheFor mcc = resourceInfo.getResourceMethod().getAnnotation(CacheFor.class);
    if( mcc!=null ) {
        cc = mcc;
    }
    if (cc!=null) {
        if( cc.value() == 0 ) {
            context.register(NoCacheFilter.class);
        } else if( cc.value() > 0 ) {
            context.register(new CacheFilter("max-age= " + cc.unit().toSeconds(cc.value())));
        }
    } else {
        context.register(NoCacheFilter.class);
    }
}

@Override
public boolean configure(FeatureContext context) {
    InjectionManager injectionManager = InjectionManagerProvider.getInjectionManager(context);
    ServiceLocator locator;
    if (injectionManager instanceof ImmediateHk2InjectionManager) {
        locator = ((ImmediateHk2InjectionManager) injectionManager).getServiceLocator();
    } else if (injectionManager instanceof DelayedHk2InjectionManager) {
        locator = ((DelayedHk2InjectionManager) injectionManager).getServiceLocator();
    } else {
        throw new IllegalStateException("expected an hk2 injection manager");
    }
    GuiceBridge.getGuiceBridge().initializeGuiceBridge(locator);
    // register all your modules, here
    Injector injector = Guice.createInjector(new GreetingModule());
    GuiceIntoHK2Bridge guiceBridge = locator.getService(GuiceIntoHK2Bridge.class);
    guiceBridge.bridgeGuiceInjector(injector);
    return true;
}

@Override
public boolean configure(final FeatureContext context) {
    final Configuration config = context.getConfiguration();

    if (!config.isRegistered(VelocityViewProcessor.class)) {
        // Template Processor.
        context.register(VelocityViewProcessor.class);

        // MvcFeature.
        if (!config.isRegistered(MvcFeature.class)) {
            context.register(MvcFeature.class);
        }

        return true;
    }
    return false;
}

@Override
public boolean configure(final FeatureContext context) {
    final Configuration config = context.getConfiguration();

    if (!config.isRegistered(FreemarkerViewProcessor.class)) {
        // Template Processor.
        context.register(FreemarkerViewProcessor.class);

        // MvcFeature.
        if (!config.isRegistered(MvcFeature.class)) {
            context.register(MvcFeature.class);
        }

        return true;
    }
    return false;
}

@Override
public void configure(final ResourceInfo resourceInfo, final FeatureContext configuration) {
  AnnotatedMethod am = new AnnotatedMethod(resourceInfo.getResourceMethod());

  // RolesAllowed on the method takes precedence over PermitAll
  RolesAllowed ra = am.getAnnotation(RolesAllowed.class);
  if (ra != null) {
    configuration.register(AuthCheckFilter.INSTANCE);
    return;
  }

  // PermitAll takes precedence over RolesAllowed on the class
  // This avoids putting AuthCheckFilter in the request flow for all path's which
  // are defined under PermitAll annotation. That is requests for "/", "/login", "/mainLogin" and "/spnegoLogin"
  // path's doesn't go through AuthCheckFilter.
  if (am.isAnnotationPresent(PermitAll.class)) {
    // Do nothing.
    return;
  }

  // RolesAllowed on the class takes precedence over PermitAll
  ra = resourceInfo.getResourceClass().getAnnotation(RolesAllowed.class);
  if (ra != null) {
    configuration.register(AuthCheckFilter.INSTANCE);
  }
}

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {

    if (resourceInfo.getResourceClass().getName()
            .startsWith(RootResource.class.getPackage().getName() + ".") == false) {
        return;
    }

    Permissions permissions = resourceInfo.getResourceMethod().getAnnotation(Permissions.class);
    if (permissions == null) {
        permissions = resourceInfo.getResourceClass().getAnnotation(Permissions.class);
    }
    if (permissions == null) {
        //TODO
        Logger.getLogger(PermissionProvider.class.getName())
                .warning(String.format("%s not annotated @Permissions",
                        resourceInfo.getResourceMethod().toGenericString()));
        return;
    }
    context.register(new PermissionTester(permissions));
}

@Override
public boolean configure(FeatureContext context) {
    context.register(MoxyJsonFeature.class);
    context.register(MoxyXmlFeature.class);
    context.register(MultiPartFeature.class);

    // internal features
    context.register(CacheFilter.class);
    context.register(GenericExceptionMapper.class);
    context.register(XmlMessageBodyReader.class);
    context.register(XmlMessageBodyWriter.class);

    Configuration.instance().getStrings("APP.Jersey.Features").forEach(cn -> {
        try {
            LOGGER.info("Register Jersey Feature: {}", cn);
            context.register(this.getClass().getClassLoader().loadClass(cn));
        } catch (ClassNotFoundException e) {
            LOGGER.error(e.getMessage(), e);
        }
    });

    return true;
}

@Test
public void shouldRegisterFilterWhenIsPermitAllReturnsFalse() throws Exception {
    // given
    AuthenticationFeature feature = new AuthenticationFeature() {
        @Override
        boolean isPermitAll(ResourceInfo resourceInfo) {
            return false;
        }
    };

    // when
    FeatureContext context = mock(FeatureContext.class);
    feature.configure(mock(ResourceInfo.class), context);

    // then
    verify(context).register(any(AuthenticationFilter.class));
}

@Test
public void shouldNotRegisterFilterWhenIsPermitAllReturnsTrue() throws Exception {
    // given
    AuthenticationFeature feature = new AuthenticationFeature() {
        @Override
        boolean isPermitAll(ResourceInfo resourceInfo) {
            return true;
        }
    };

    // when
    FeatureContext context = mock(FeatureContext.class);
    feature.configure(mock(ResourceInfo.class), context);

    // then
    verify(context, never()).register(any(AuthenticationFilter.class));
}

@Override
  public boolean configure(final FeatureContext context) {

    PluginLoader.INSTANCE.plugins.get().stream()
.filter(module -> module.jacksonFeatureProperties()!=null)
.map(Plugin::jacksonFeatureProperties)
.map(fn->fn.apply(context))
.forEach(map -> {
    addAll(map,context);
});


      JacksonJaxbJsonProvider provider = new JacksonJaxbJsonProvider();
        provider.setMapper(JacksonUtil.getMapper());
          context.register(provider, new Class[]{MessageBodyReader.class, MessageBodyWriter.class});

      return true;
  }

@Override
public void configure(ResourceInfo resourceInfo, FeatureContext context) {
    Class<?> resourceClass = resourceInfo.getResourceClass();
    Method method = resourceInfo.getResourceMethod();

    boolean required = true;
    if (resourceClass.isAnnotationPresent(TenantRequired.class)) {
        required = resourceClass.getAnnotation(TenantRequired.class).value();
    }

    if (method.isAnnotationPresent(TenantRequired.class)) {
        required = method.getAnnotation(TenantRequired.class).value();
    }

    if (required) {
        context.register(TENANT_FILTER);
    }
}

@Override
public boolean configure(FeatureContext context) {

    // for now only supporting Guice injection to resources

    // TODO: if we want to inject web environment objects back into Guice
    // services or to use JSR-330 annotations in Resources, we need
    // org.glassfish.hk2:guice-bridge integration

    // This feature can inject HK2 ServiceLocator in constructor, and then
    // we can bridge it both ways with Guice

    context.register(new AbstractBinder() {
        @Override
        protected void configure() {
            bind(GuiceInjectInjector.class).to(new TypeLiteral<InjectionResolver<com.google.inject.Inject>>() {
            }).in(Singleton.class);
        }
    });

    return true;
}

private void applyInternalCommonConfig(FeatureContext context, InternalCommonConfig internalCommonConfig)
{
    for ( Class<?> clazz : internalCommonConfig.getClasses() )
    {
        log.info(String.format("Registering %s as a component", clazz));
        context.register(clazz);
    }
    for ( Object obj : internalCommonConfig.getInstances() )
    {
        log.info(String.format("Registering instance of %s as a component", obj.getClass()));
        context.register(obj);
    }
    for ( Map.Entry<String, Object> entry : internalCommonConfig.getProperties().entrySet() )
    {
        String key = entry.getKey();
        Object value = entry.getValue();
        log.info(String.format("Registering property key: %s\tvalue: %s", key, value));
        context.property(key, value);
    }
}

private void checkAdminGuiceFeature(final Environment environment, final JerseyEnvironment jerseyEnvironment)
{
    try
    {
        Feature feature = new Feature()
        {
            @Override
            public boolean configure(FeatureContext context)
            {
                for ( Object obj : environment.jersey().getResourceConfig().getSingletons() )
                {
                    if ( obj instanceof InternalFeatureRegistrations )
                    {
                        ((InternalFeatureRegistrations)obj).apply(context);
                    }
                }
                return true;
            }
        };
        jerseyEnvironment.register(feature);
    }
    catch ( Exception ignore )
    {
        // ignore - GuiceBundle not added
    }
}