Java Feature类代码示例

import javax.ws.rs.core.Feature; //导入依赖的package包/类
@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);
		}
	}
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
/**
 * 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;
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
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)
            );
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
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);
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
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;
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
@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());
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
@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);
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
@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"));
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
@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;
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
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
    }
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
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;
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
@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);
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
@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);
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
@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);
}
 

import javax.ws.rs.core.Feature; //导入依赖的package包/类
/**
 * 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;
      }

   });
}