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

@Test
public void testRegister() throws Exception {
    logger.info("start Register test");
    Client client = newClient();
    Map<Class<?>, Integer> myContracts = new HashMap<Class<?>, Integer>();
    myContracts.put(Feature.class, 1200);
    client.register(MyComponent.class, myContracts);
    Configuration configuration = client.getConfiguration();
    Set<Class<?>> classes = configuration.getClasses();
    for (Class<?> clazz : classes) {
        if (MyComponent.class.isAssignableFrom(clazz)) {
            Map<Class<?>, Integer> contracts = configuration.getContracts(clazz);
            int priority = contracts.get(Feature.class);
            assertTrue("Only standard: Feature, DynamicFeature, WriterInterceptor, "
                    + "ReaderInterceptor, ContainerResponseFilter, " + "ContainerRequestFilter, "
                    + "ClientResponseFilter, ClientRequestFilter, " + "ExceptionMapper, MessageBodyWriter, "
                    + "MessageBodyReader,ParamConverterProvider or implemented: InjectorFactory, "
                    + "StringParameterUnmarshaller, StringConverter, " + "ContextResolver, PostProcessInterceptor, "
                    + "PreProcessInterceptor, ClientExecutionInterceptor, ClientExceptionMapper"
                    + "can be registered as contracts. Registered priority", priority == 1200);
        }
    }
}

/**
 * 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;
}

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)
            );
}

public synchronized void addFeature(ApplicationKey application,
        Feature feature) {
    if (application == null || feature == null) {
        throw new RuntimeException(
                "Unable to add feature for " + application);
    }

    List<Feature> list;

    if (features.containsKey(application)) {
        list = features.get(application);
    } else {
        list = new ArrayList<>();
        features.put(application, list);
    }

    list.add(feature);
}

protected ClientConfig createConfig(Set<Feature> features) {
    ClientConfig config = new ClientConfig();
    config.property(ClientProperties.FOLLOW_REDIRECTS, followRedirects);
    config.property(ClientProperties.READ_TIMEOUT, readTimeoutMs);
    config.property(ClientProperties.CONNECT_TIMEOUT, connectTimeoutMs);
    config.property(ClientProperties.ASYNC_THREADPOOL_SIZE, asyncThreadPoolSize);

    features.forEach(f -> config.register(f));

    if (compression) {
        config.register(new EncodingFeature(GZipEncoder.class));
    }

    configRequestLogging(config);

    return config;
}

@Test
public void testDefaultServiceReferencePropertiesAreAvailableInFeatures() {
    AtomicBoolean executed = new AtomicBoolean();
    AtomicReference<Object> propertyvalue = new AtomicReference<>();

    registerExtension(
        Feature.class, featureContext -> {
            executed.set(true);

            Map<String, Object> properties =
                (Map<String, Object>)
                    featureContext.getConfiguration().getProperty(
                        "osgi.jaxrs.application.serviceProperties");
            propertyvalue.set(properties.get(JAX_RS_NAME));

            return false;
        }, "Feature", JAX_RS_APPLICATION_SELECT,
        "("+ JAX_RS_NAME + "=" + JAX_RS_DEFAULT_APPLICATION + ")");

    assertTrue(executed.get());
    assertEquals(JAX_RS_DEFAULT_APPLICATION, propertyvalue.get());
}

@Test
public void testErroredExtension() {
    registerApplication(new TestApplication());

    ServiceRegistration<Feature> serviceRegistration = registerExtension(
        Feature.class,
        context -> {
            throw new RuntimeException();
        },
        "ErrorFeature",
        JAX_RS_APPLICATION_SELECT,
        "(" + JAX_RS_APPLICATION_BASE + "=/test-application)");

    RuntimeDTO runtimeDTO = _runtime.getRuntimeDTO();

    assertEquals(1, runtimeDTO.failedExtensionDTOs.length);
    assertEquals(
        serviceRegistration.getReference().getProperty("service.id"),
        runtimeDTO.failedExtensionDTOs[0].serviceId);
    assertEquals(
        DTOConstants.FAILURE_REASON_UNKNOWN,
        runtimeDTO.failedExtensionDTOs[0].failureReason);
}

@Test
public void testFeatureExtension() {
    WebTarget webTarget = createDefaultTarget().path("/test-application");

    registerApplication(new TestApplication());

    registerExtension(
        Feature.class,
        context -> {
            context.register(new TestFilter());

            return true;
        },
        "Feature",
        JAX_RS_APPLICATION_SELECT,
        "(" + JAX_RS_APPLICATION_BASE + "=/test-application)");

    Response response = webTarget.request().get();

    assertEquals("Hello application", response.readEntity(String.class));

    assertEquals("true", response.getHeaders().getFirst("Filtered"));
}

@Singleton
@Provides
private ResourceConfig createResourceConfig(Injector injector,
                                            Set<Feature> features,
                                            Set<DynamicFeature> dynamicFeatures,
                                            @JerseyResource Set<Object> resources, Set<Package> packages,
                                            @JerseyResource Map<String, Object> properties) {

    ResourceConfig config = new ResourceConfig();

    packages.forEach(p -> config.packages(true, p.getName()));
    resources.forEach(r -> config.register(r));

    features.forEach(f -> config.register(f));
    dynamicFeatures.forEach(df -> config.register(df));

    config.addProperties(properties);

    // TODO: make this pluggable?
    config.register(ResourceModelDebugger.class);

    // register Guice Injector as a service in Jersey HK2, and GuiceBridgeFeature as a
    GuiceBridgeFeature.register(config, injector);

    return config;
}

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
    }
}

public static AccessToken configureOAuth1(
  String consumerKey,
  String consumerSecret,
  String token,
  String tokenSecret,
  ClientBuilder clientBuilder
) {
  ConsumerCredentials consumerCredentials = new ConsumerCredentials(consumerKey, consumerSecret);

  AccessToken accessToken = new AccessToken(token, tokenSecret);
  Feature feature = OAuth1ClientSupport.builder(consumerCredentials)
      .feature()
      .accessToken(accessToken)
      .build();
  clientBuilder.register(feature);

  return accessToken;
}

@Override
public Application configure() {

    EntityResolver mockResolver = mock(EntityResolver.class);
    DataChannel mockChannel = mock(DataChannel.class);
    when(mockChannel.getEntityResolver()).thenReturn(mockResolver);

    ServerRuntime runtime = mock(ServerRuntime.class);
    when(runtime.getChannel()).thenReturn(mockChannel);

    Feature lrFeature = LinkRestBuilder.build(runtime);

    Feature testFeature = new Feature() {

        @Override
        public boolean configure(FeatureContext context) {
            context.register(ExceptionResource.class);
            return true;
        }
    };

    return new ResourceConfig().register(testFeature).register(lrFeature);
}

@Override
public Application configure() {

    Feature lrFeature = new LinkRestBuilder().adapter(new LinkRestAdapter() {

        @Override
        public void contributeToRuntime(Binder binder) {
            binder.bind(SelectProcessorFactory.class).toProvider(PojoSelectProcessorFactoryProvider.class);
            binder.bind(PojoFetchStage.class).to(PojoFetchStage.class);
            binder.bind(PojoDB.class).toInstance(pojoDB);
        }

        @Override
        public void contributeToJaxRs(Collection<Feature> features) {
            // nothing to contribute...
        }
    }).build();

    Feature unitFeature = context -> {
        doAddResources(context);
        return true;
    };

    return new ResourceConfig().register(unitFeature).register(lrFeature);
}

@Override
public Application configure() {

    EntityResolver mockResolver = mock(EntityResolver.class);
    DataChannel mockChannel = mock(DataChannel.class);
    when(mockChannel.getEntityResolver()).thenReturn(mockResolver);

    ServerRuntime runtime = mock(ServerRuntime.class);
    when(runtime.getChannel()).thenReturn(mockChannel);

    Feature lrFeature = LinkRestBuilder.build(runtime);

    Feature feature = new Feature() {

        @Override
        public boolean configure(FeatureContext context) {
            context.register(SimpleResponseResource.class);
            return true;
        }
    };

    return new ResourceConfig().register(feature).register(lrFeature);
}

/**
 * Create a new UriTemplateApplication.
 * 
 */
public UriTemplateApplication()
{
   registerClasses(UriTemplateResource.class);
   registerClasses(SchemaResource.class);
   register(new Feature()
   {

      @Override
      public boolean configure(final FeatureContext context)
      {
         final String disableMoxy = CommonProperties.MOXY_JSON_FEATURE_DISABLE + '.'
               + context.getConfiguration().getRuntimeType().name().toLowerCase();
         context.property(disableMoxy, true);

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

   });
}

@Test
public void testConfiguration() throws Exception {
    logger.info("start REST Configuration test");
    Client client = newClient();
    Configuration configuration = client.getConfiguration();
    Set<Class<?>> classes = configuration.getClasses();
    for (Class<?> clazz : classes) {
        assertTrue("verify if the class is a rest component or provider",
                MessageBodyReader.class.isAssignableFrom(clazz) || MessageBodyWriter.class.isAssignableFrom(clazz)
                        || clazz.isAnnotationPresent(Provider.class)
                        || DynamicFeature.class.isAssignableFrom(clazz));
        Map<Class<?>, Integer> contracts = configuration.getContracts(clazz);
        assertFalse("each class has different contracts", contracts.isEmpty());
        for (Class<?> contract : contracts.keySet()) {
            int value = contracts.get(contract);
            assertTrue("verify if the contract is a rest component or provider",
                    value == 5000 || value == 4000 || value == 3000 || value == 0);
        }
    }
    Set<Object> instances = configuration.getInstances();
    assertTrue("by default there are not instances", instances.isEmpty());
    Map<String, Object> properties = configuration.getProperties();
    assertTrue("by default there are not properties", properties.isEmpty());
    MyComponent myComponent = new MyComponent();
    client.register(myComponent);
    instances = configuration.getInstances();
    assertFalse("Added instance", instances.isEmpty());
    for (Object instance : instances) {
        if (instance instanceof MyComponent)
            assertTrue("MyComponent is registered and active", configuration.isEnabled((Feature) instance));
    }
    assertEquals("Added property through MyComponent", 1, properties.size());
    boolean property = (Boolean) properties.get("configured_myComponent");
    assertEquals("configured_myComponent ok!", true, property);
    assertEquals("type CLIENT by default", CLIENT, configuration.getRuntimeType());
}

@SuppressWarnings("unchecked")
private void registerFeature(final Class<?> c) {
    if (!Feature.class.isAssignableFrom(c)) {
        return;
    }

    final Class<? extends Feature> featureClass = (Class<? extends Feature>) c;
    try {
        get(featureClass).configure(this);
    } catch (final Exception ex) {
        throw new MinijaxException(ex);
    }
}

@Inject
public DefaultResourceConfigProvider(Set<Feature> features,
                                     Set<Class<? extends Feature>> featureClasses,
                                     Injector injector) {
  this.features = features;
  this.featureClasses = featureClasses;
  this.injector = injector;
}

@ProvidesIntoSet
Feature exceptionMappersFeature() {
  return (context) -> {
    context.register(RuntimeExceptionMapper.class);
    context.register(WebApplicationExceptionMapper.class);
    return true;
  };
}

@Test
public void configure() throws Exception {
  Feature feature = new BoundWebResourcesFeature(injector);

  feature.configure(featureContext);

  Mockito.verify(featureContext, Mockito.times(2)).register(Matchers.any(Object.class));
}

@ProvidesIntoSet
Feature customFeature() {
  return (context) -> {
    context.register(xPoweredByFilter());
    context.register(requestLoggerFilter());

    return true;
  };
}

public HttpClientFactory createClientFactory(Injector injector, Set<Feature> features) {
    ClientConfig config = createConfig(features);

    // register Guice Injector as a service in Jersey HK2, and
    // GuiceBridgeFeature as a
    ClientGuiceBridgeFeature.register(config, injector);

    KeyStore trustStore = createTrustStore();

    return new DefaultHttpClientFactory(config, trustStore, createAuthFilters(injector));
}

protected Multibinder<Feature> contributeFeatures() {

        if (features == null) {
            features = Multibinder.newSetBinder(binder, Feature.class, JerseyClientFeatures.class);
        }

        return features;
    }

@Provides
@Singleton
HttpClientFactory createClientFactory(ConfigurationFactory configurationFactory, Injector injector,
                                      @JerseyClientFeatures Set<Feature> features) {
    return configurationFactory.config(HttpClientFactoryFactory.class, configPrefix).createClientFactory(injector,
            features);
}

@Test
public void testFeatureProvider() {

    Feature feature = mock(Feature.class);
    LrFeatureProvider featureProvider = mock(LrFeatureProvider.class);
    when(featureProvider.feature(any(Injector.class))).thenReturn(feature);

    testFactory.app("-c", "classpath:LinkRestModuleExtenderIT.yml")
            .autoLoadModules()
            .module(b -> LinkRestModule.extend(b).addFeatureProvider(featureProvider))
            .start();

    verify(featureProvider).feature(any(Injector.class));
    verify(feature).configure(any(FeatureContext.class));
}

@Test
public void testServiceReferencePropertiesAreAvailableInFeatures() {
    AtomicBoolean executed = new AtomicBoolean();
    AtomicReference<Object> propertyvalue = new AtomicReference<>();

    registerExtension(
        Feature.class, featureContext -> {
            executed.set(true);

            Map<String, Object> properties =
                (Map<String, Object>)
                    featureContext.getConfiguration().getProperty(
                        "osgi.jaxrs.application.serviceProperties");
            propertyvalue.set(properties.get("property"));

            return false;
        }, "Feature", JAX_RS_APPLICATION_SELECT, "(property=true)");

    registerApplication(
        new Application() {
        @Override
        public Set<Object> getSingletons() {
            return Collections.singleton(
                new Object() {

                    @GET
                    public String hello() {
                        return "hello";
                    }
                });
        }
    }, JAX_RS_NAME, "test", "property", true);

    assertTrue(executed.get());
    assertEquals(true, propertyvalue.get());
}

@Test
public void testServiceReferencePropertiesAreAvailableInStaticFeatures() {
    AtomicBoolean executed = new AtomicBoolean();
    AtomicReference<Object> propertyvalue = new AtomicReference<>();

    registerApplication(
        new Application() {
            @Override
            public Set<Object> getSingletons() {
                return new HashSet<>(Arrays.asList(
                    (Feature)featureContext -> {
                        executed.set(true);

                        Map<String, Object> properties =
                            (Map<String, Object>)
                                featureContext.getConfiguration().getProperty(
                                    "osgi.jaxrs.application.serviceProperties");
                        propertyvalue.set(properties.get("property"));

                        return false;
                    },
                    new Object() {

                        @GET
                        public String hello() {
                            return "hello";
                        }
                    }
                    ));
            }
        }, JAX_RS_NAME, "test", "property", true);

    assertTrue(executed.get());
    assertEquals(true, propertyvalue.get());
}

@Test
public void testFeatureProvider() {

    Feature feature = mock(Feature.class);
    LrFeatureProvider featureProvider = mock(LrFeatureProvider.class);
    when(featureProvider.feature(any(Injector.class))).thenReturn(feature);

    testFactory.app("-c", "classpath:LinkRestModuleExtenderIT.yml")
            .autoLoadModules()
            .module(b -> LinkRestModule.extend(b).addFeatureProvider(featureProvider))
            .start();

    verify(featureProvider).feature(any(Injector.class));
    verify(feature).configure(any(FeatureContext.class));
}

private Client createClient(ObjectMapper objectMapper) {
    final ClientConfig clientConfig = new ClientConfig();
    clientConfig.property(ClientProperties.FOLLOW_REDIRECTS, true);
    clientConfig.property(ClientProperties.CONNECT_TIMEOUT, 3000);
    clientConfig.property(ClientProperties.READ_TIMEOUT, 3000);
    clientConfig.property(ClientProperties.FEATURE_AUTO_DISCOVERY_DISABLE, true);

    final JacksonJsonProvider jacksonJsonProvider = new JacksonJsonProvider(objectMapper);
    final Client client = ClientBuilder.newClient(clientConfig).register(jacksonJsonProvider).register(MultiPartFeature.class);
    final Feature feature = new LoggingFeature(JERSEY_LOGGER, Level.FINE, LoggingFeature.Verbosity.PAYLOAD_ANY, null);
    client.register(feature);
    return client;
}

@Inject
public DaggerApplication(Set<Feature> features,
                         @Resources Set<Object> resources,
                         @Providers Set<Object> providers)
{
    this.singletons = ImmutableSet.builder()
                                  .addAll(features)
                                  .addAll(resources)
                                  .addAll(providers)
                                  .build();
}

/**
 * {@inheritDoc}
 */
@Override
public void setup(final Application application) {

    final Set<ClassInfo> classInfoSet = Sets.newLinkedHashSet();
    subscribeSystemEvent(ClassFoundEvent.class, event -> event.accept(info -> {
        if (info.containsAnnotations(Service.class)) {
            classInfoSet.add(info);
            return true;
        }
        return false;
    }));

    final Feature localResource = new Feature() {

        @Inject
        private ServiceLocator locator;

        @Override
        public boolean configure(FeatureContext context) {
            for (ClassInfo classInfo : classInfoSet) {
                ServiceLocatorUtilities.addClasses(locator, classInfo.toClass());
            }
            classInfoSet.clear();
            return true;
        }
    };

    application.register(localResource);
}

@Override
public boolean configure(FeatureContext context) {
    if (!context.getConfiguration().isRegistered(ShiroDynamicFeature.class)) {

        if (!context.getConfiguration().isRegistered(Cache.Feature.class)) {
            context.register(Cache.Feature.class)
                    .register(this);
            return false;
        }

        String conf = (String) context.getConfiguration().getProperty("security.shiro.conf");

        Ini ini = new Ini();

        InputStream in = IOUtils.getResourceAsStream(conf);
        if (in != null) {
            try {
                ini.load(in);
            } finally {
                IOUtils.closeQuietly(in);
            }
        } else {
            logger.warn("No Shiro configuration found.");
        }

        IniSecurityManagerFactory factory = new IniSecurityManagerFactory(ini, injectionManager);
        final SecurityManager securityManager = factory.getInstance();

        SecurityUtils.setSecurityManager(securityManager);

        context.register(ShiroDynamicFeature.class)
                .register(ShiroExceptionMapper.class)
                .register(new ShiroBinder(securityManager))
                .register(ShiroContainerFilter.class);

        return true;
    }
    return false;
}

@Override
public boolean configure(FeatureContext context) {

    // this gives everyone access to the LinkRest services
    context.property(LinkRestRuntime.LINK_REST_CONTAINER_PROPERTY, injector);

    @SuppressWarnings("unchecked")
    Map<String, Class> bodyWriters =
            injector.getInstance(Key.getMapOf(String.class, Class.class, LinkRestRuntime.BODY_WRITERS_MAP));

    for (Class<?> type : bodyWriters.values()) {
        context.register(type);
    }

    context.register(ResponseStatusDynamicFeature.class);

    context.register(EntityUpdateReader.class);
    context.register(EntityUpdateCollectionReader.class);

    for (Class<?> c : extraComponents) {
        context.register(c);
    }

    for (Feature f : extraFeatures) {
        f.configure(context);
    }

    return true;
}

@Test
public void testMapException_Standard() {
    LinkRestBuilder builder = new LinkRestBuilder();
    Feature f = builder.build();

    FeatureContext context = mock(FeatureContext.class);

    f.configure(context);

    verify(context).register(ValidationExceptionMapper.class);
}

@Test
public void testMapException_Custom() {
    LinkRestBuilder builder = new LinkRestBuilder().mapException(TestValidationExceptionMapper.class);
    Feature f = builder.build();

    FeatureContext context = mock(FeatureContext.class);

    f.configure(context);

    verify(context).register(TestValidationExceptionMapper.class);
    verify(context, never()).register(ValidationExceptionMapper.class);
}

@Test
public void testBuild_Adapter() {

    final Feature adapterFeature = mock(Feature.class);

    LinkRestAdapter adapter = mock(LinkRestAdapter.class);
    doAnswer((Answer<Object>) invocation -> {
        @SuppressWarnings("unchecked")
        Collection<Feature> c = (Collection<Feature>) invocation.getArguments()[0];
        c.add(adapterFeature);
        return null;
    }).when(adapter).contributeToJaxRs(anyCollectionOf(Feature.class));

    final IRequestParser mockParser = mock(IRequestParser.class);
    doAnswer((Answer<Object>) invocation -> {
        Binder b = (Binder) invocation.getArguments()[0];
        b.bind(IRequestParser.class).toInstance(mockParser);
        return null;
    }).when(adapter).contributeToRuntime(any(Binder.class));

    LinkRestRuntime runtime = new LinkRestBuilder().adapter(adapter).build();

    assertSame(mockParser, runtime.service(IRequestParser.class));

    FeatureContext context = mock(FeatureContext.class);
    runtime.configure(context);
    verify(adapterFeature).configure(context);
}

@Override
public Application configure() {

    LinkRestRuntime lrFeature = doConfigure().build();

    Feature unitFeature = context -> {
        doAddResources(context);
        return true;
    };

    return new ResourceConfig()
            .register(unitFeature)
            .register(lrFeature);
}

@Override
public Feature feature(Injector injector) {
    return context -> {
        context.register(SenchaDeletePayloadParser.class);
        return true;
    };
}

public SensorSafeResourceConfig() {

    // Register OAuthServerFeature
    Feature oauthFeature = new SensorSafeOAuth1ServerFeature(oauthProvider, REQUEST_TOKEN_API_PATH, ACCESS_TOKEN_API_PATH);
    register(oauthFeature);

    // Register RolesAllowedDynamicFeature
    register(RolesAllowedDynamicFeature.class);
}

private boolean isJaxrsFeatureOrProvider(Object object) {
  Class<?> clazz = object.getClass();
  boolean isFeature = Feature.class.isAssignableFrom(clazz);
  boolean isProvider = clazz.isAnnotationPresent(javax.ws.rs.ext.Provider.class);
  return isFeature || isProvider;
}