javax.ws.rs.core.Configurable Java Examples

@Test
public void testExceptionMapperIsolation() throws Exception {
  TestApp app1 = new TestApp("/app1");
  TestApp app2 = new TestApp("/app2") {
    @Override
    public void setupResources(final Configurable<?> config, final TestRestConfig appConfig) {
      config.register(RestResource.class);
      config.register(TestExceptionMapper.class);
    }
  };

  server.registerApplication(app1);
  server.registerApplication(app2);
  server.start();

  assertThat(makeGetRequest( "/app1/exception"), is(Code.INTERNAL_SERVER_ERROR));
  assertThat(makeGetRequest("/app2/exception"), is(Code.ENHANCE_YOUR_CALM));

}
 

private FeatureContext createServerFeatureContext() {
    final FeatureContextImpl featureContext = new FeatureContextImpl();
    final ServerConfigurableFactory factory = getBus().getExtension(ServerConfigurableFactory.class);
    final Configurable<FeatureContext> configImpl = (factory == null) 
        ? new ServerFeatureContextConfigurable(featureContext) 
            : factory.create(featureContext);
    featureContext.setConfigurable(configImpl);

    if (application != null) {
        Map<String, Object> appProps = application.getProvider().getProperties();
        for (Map.Entry<String, Object> entry : appProps.entrySet()) {
            configImpl.property(entry.getKey(), entry.getValue());
        }
    }
    return featureContext;
}
 

protected Configurable<?> registerComponents(Configurable<?> configurable) {
	synchronized (components) {
		for (JaxRSComponent ext : components) {
			List<Class<?>> noPriorityContracts = new ArrayList<Class<?>>();
			Map<Class<?>, Integer> priorityContracts = new HashMap<Class<?>, Integer>();
			for (Iterator<Class<?>> it = ext.contracts.keySet().iterator(); it.hasNext();) {
				Class<?> contractClass = it.next();
				Integer priority = ext.contracts.get(contractClass);
				if (priority.equals(NO_PRIORITY))
					noPriorityContracts.add(contractClass);
				else
					priorityContracts.put(contractClass, priority);
			}
			if (noPriorityContracts.size() > 0)
				configurable.register(ext.component,
						noPriorityContracts.toArray(new Class<?>[noPriorityContracts.size()]));
			if (priorityContracts.size() > 0)
				configurable.register(ext.component, priorityContracts);
		}
	}
	return configurable;
}
 

@Test
public void testStaticResourceIsolation() throws Exception {
  TestApp app1 = new TestApp("/app1");
  TestApp app2 = new TestApp("/app2") {
    @Override
    public void setupResources(final Configurable<?> config, final TestRestConfig appConfig) {
      config.register(RestResource.class);
      config.property(ServletProperties.FILTER_STATIC_CONTENT_REGEX, "/(index\\.html|)");
    }

    @Override
    protected ResourceCollection getStaticResources() {
      return new ResourceCollection(Resource.newClassPathResource("static"));
    }
  };

  server.registerApplication(app1);
  server.registerApplication(app2);
  server.start();

  assertThat(makeGetRequest("/app1/index.html"), is(Code.NOT_FOUND));
  assertThat(makeGetRequest("/app2/index.html"), is(Code.OK));
}
 

@Override
public void configureBaseApplication(Configurable<?> config, Map<String, String> metricTags) {
  // Would call this but it registers additional, unwanted exception mappers
  // super.configureBaseApplication(config, metricTags);
  // Instead, just copy+paste the desired parts from Application.configureBaseApplication() here:
  JacksonMessageBodyProvider jsonProvider = new JacksonMessageBodyProvider(getJsonMapper());
  config.register(jsonProvider);
  config.register(JsonParseExceptionMapper.class);

  // Don't want to buffer rows when streaming JSON in a request to the query resource
  config.property(ServerProperties.OUTBOUND_CONTENT_LENGTH_BUFFER, 0);
  if (isUiEnabled) {
    loadUiWar();
    config.property(ServletProperties.FILTER_STATIC_CONTENT_REGEX, "/(static/.*|.*html)");
  }
}
 

@Test
public void testClientFilterContractsOnServerFeatureIsRejected() {
    FeatureContextImpl featureContext = new FeatureContextImpl();
    Configurable<FeatureContext> configurable = new ConfigurableImpl<>(featureContext, RuntimeType.SERVER);
    featureContext.setConfigurable(configurable);
    featureContext.register(TestFilter.class);
    Configuration config = configurable.getConfiguration();
    Map<Class<?>, Integer> contracts = config.getContracts(TestFilter.class);
    assertFalse(contracts.containsKey(ClientRequestFilter.class));
    assertFalse(contracts.containsKey(ClientResponseFilter.class));
    assertTrue(contracts.containsKey(ContainerRequestFilter.class));
    assertTrue(contracts.containsKey(ContainerResponseFilter.class));
}
 

@Override
protected Servlet createServlet(Configurable<?> configurable, RSARemoteServiceRegistration registration) {
	Map<Class<?>, Object> extensions = new HashMap<>();
	DestinationRegistry destinationRegistry = new DestinationRegistryImpl();
	HTTPTransportFactory httpTransportFactory = new HTTPTransportFactory(destinationRegistry);
	extensions.put(HTTPTransportFactory.class, httpTransportFactory);
	extensions.put(DestinationRegistry.class, destinationRegistry);
	Bus bus = new ExtensionManagerBus(extensions, null, getClass().getClassLoader());
	org.apache.cxf.transport.DestinationFactoryManager destinationFactoryManager = bus
			.getExtension(org.apache.cxf.transport.DestinationFactoryManager.class);
	for (String url : HTTPTransportFactory.DEFAULT_NAMESPACES) {
		destinationFactoryManager.registerDestinationFactory(url, httpTransportFactory);
	}
	return new DPCXFNonSpringJaxrsServlet(registration, (CXFServerConfigurable) configurable, destinationRegistry, bus);
}
 

@Override
protected void registerExtensions(Configurable<?> configurable, RSARemoteServiceRegistration registration) {
	// This overrides/replaces superclass implementation to setup
	// ObjectMapperContextResolver, and Jackson Jaxb Json parsing/writing
	configurable.register(new ObjectMapperContextResolver(), ContextResolver.class);
	configurable.register(JsonParseExceptionMapper.class);
	configurable.register(JsonMappingExceptionMapper.class);
	configurable.register(new JacksonJaxbJsonProvider(), jacksonPriority);
}
 

/**
 * Register a body provider and optional exception mapper for (de)serializing JSON in
 * request/response entities.
 * @param config The config to register the provider with
 * @param restConfig The application's configuration
 * @param registerExceptionMapper Whether or not to register an additional exception mapper for
 *                                handling errors in (de)serialization
 */
protected void registerJsonProvider(
    Configurable<?> config,
    T restConfig,
    boolean registerExceptionMapper
) {
  ObjectMapper jsonMapper = getJsonMapper();
  JacksonMessageBodyProvider jsonProvider = new JacksonMessageBodyProvider(jsonMapper);
  config.register(jsonProvider);
  if (registerExceptionMapper) {
    config.register(JsonParseExceptionMapper.class);
  }
}
 

/**
 * Register standard components for a JSON REST application on the given JAX-RS configurable,
 * which can be either an ResourceConfig for a server or a ClientConfig for a Jersey-based REST
 * client.
 */
public void configureBaseApplication(Configurable<?> config, Map<String, String> metricTags) {
  T restConfig = getConfiguration();

  registerJsonProvider(config, restConfig, true);
  registerFeatures(config, restConfig);
  registerExceptionMappers(config, restConfig);

  config.register(new MetricsResourceMethodApplicationListener(getMetrics(), "jersey",
                                                               metricTags, restConfig.getTime()));

  config.property(ServerProperties.BV_SEND_ERROR_IN_RESPONSE, true);
  config.property(ServerProperties.WADL_FEATURE_DISABLE, true);
}
 

@Test
public void testFeatureDisabledInstance() {
    FeatureContextImpl featureContext = new FeatureContextImpl();
    Configurable<FeatureContext> configurable = new ConfigurableImpl<>(featureContext, RuntimeType.SERVER);
    featureContext.setConfigurable(configurable);
    Feature feature = new DisablableFeature();
    featureContext.register(feature);

    Configuration config = configurable.getConfiguration();
    assertFalse(config.isEnabled(feature));
}
 

@Test
public void testFeatureDisabledClass() {
    FeatureContextImpl featureContext = new FeatureContextImpl();
    Configurable<FeatureContext> configurable = new ConfigurableImpl<>(featureContext, RuntimeType.SERVER);
    featureContext.setConfigurable(configurable);
    featureContext.register(DisablableFeature.class);

    Configuration config = configurable.getConfiguration();
    assertFalse(config.isEnabled(DisablableFeature.class));
}
 

@Override
public void setupResources(Configurable<?> config, TestRestConfig appConfig) {
  resourceConfig = config;
  config.register(PrivateResource.class);
  // ensures the dispatch error message gets shown in the response
  // as opposed to a generic error page
  config.property(ServerProperties.RESPONSE_SET_STATUS_OVER_SEND_ERROR, true);
}
 

@Test
public void testSubClassIsRegisteredOnConfigurable() {
    FeatureContextImpl featureContext = new FeatureContextImpl();
    Configurable<FeatureContext> configurable = new ConfigurableImpl<>(featureContext, RuntimeType.SERVER);
    featureContext.setConfigurable(configurable);
    featureContext.register(ContainerResponseFilterSubClassImpl.class);
    Configuration config = configurable.getConfiguration();
    Map<Class<?>, Integer> contracts = config.getContracts(ContainerResponseFilter.class);
    assertEquals(1, contracts.size());
    assertTrue(contracts.containsKey(ContainerResponseFilter.class));
}
 

@Override
public void register(final Configurable<?> config, final TestApp app) {
  final TestRestConfig restConfig = app.getConfiguration();
  assertNotNull(restConfig);

  config.register(new RestResource());
}
 

@Override
public void setupResources(Configurable<?> configurable, KsqlRestConfig ksqlRestConfig) {
  configurable.register(new MockKsqlResources());
  configurable.register(streamedQueryResource);
  configurable.register(new MockStatusResource());
  configurable.property(ServerProperties.OUTBOUND_CONTENT_LENGTH_BUFFER, 0);
}
 

@Override
public void setupResources(Configurable<?> config, KsqlRestConfig appConfig) {
  config.register(rootDocument);
  config.register(new ServerInfoResource(serverInfo));
  config.register(statusResource);
  config.register(ksqlResource);
  config.register(streamedQueryResource);
  config.register(new KsqlExceptionMapper());
}
 

public void setConfigurable(Configurable<?> configurable) {
    this.cfg = configurable;
}
 

public Configurable<?> getConfigurable() {
    return cfg;
}
 

public FeatureContextImpl(Configurable<?> cfg) {
    this.cfg = cfg;
}
 

@Override
public void setupResources(final Configurable<?> config, final TestRestConfig appConfig) {
  config.register(RestResource.class);
}
 

@Override
public void setupResources(Configurable<?> config, HelloWorldRestConfig appConfig) {
  config.register(new HelloWorldResource(appConfig));
  config.property(ServletProperties.FILTER_STATIC_CONTENT_REGEX, "/(static/.*|.*\\.html|)");
}
 

public void configureBaseApplication(Configurable<?> config) {
  configureBaseApplication(config, null);
}
 

@Override
public Configurable<FeatureContext> create(FeatureContext context) {
    return new CdiServerFeatureContextConfigurable(context, beanManager);
}
 

@SuppressWarnings("rawtypes")
@Override
protected Configurable createConfigurable() {
	return new ClientConfig();
}
 

@Override
public Configurable<Configurable> property(String name, Object value)
{
    config.property(name, value);
    return this;
}
 

@Override
public void register(final Configurable<?> config, final Application<?> app) {
  throw new IllegalArgumentException("Boom");
}
 

@Override
public void register(final Configurable<?> config, final Application<?> app) {
}
 

@Override
public void setupResources(Configurable<?> config, TestRestConfig appConfig) {
  resourceConfig = config;
  config.register(ZerosResource.class);
}
 

@Override
public void setupResources(final Configurable<?> config, final TestRestConfig appConfig) {
}