/**
* Registers HK2 binders into the HK2 service register.
*
* @param binders binders to be registered.
*/
public void registerAdditionalBinders(final Iterable<Binder> binders) {
final DynamicConfiguration dc = Injections.getConfiguration(locator);
for (Binder binder : binders) {
binder.bind(dc);
}
dc.commit();
}
@Override
public boolean bind(Class<?> component, Set<Class<?>> providerContracts) {
if (injector != null) {
Key<?> key = Key.get(component);
Binding<?> binding = injector.getExistingBinding(key);
// Does the constructor require Guice Binding?
if (binding == null) {
binding = injector.getBinding(key);
}
DynamicConfiguration c = Injections.getConfiguration(locator);
ServiceBindingBuilder bb =
Injections.newFactoryBinder(new GuiceBindingComponentFactory(binding));
bb.to(component);
Injections.addBinding(bb, c);
c.commit();
return true;
}
return false;
}
/**
* Create a new Jersey server-side application handler configured by a {@link Application JAX-RS
* Application (sub-)class}.
*
* @param jaxrsApplicationClass JAX-RS {@code Application} (sub-)class that will be instantiated
* and used to configure the new Jersey application handler.
*/
public ApplicationHandler(Class<? extends Application> jaxrsApplicationClass) {
this.locator = Injections.createLocator(new ServerBinder(), new ApplicationBinder());
this.application = createApplication(jaxrsApplicationClass);
this.runtimeConfig = ResourceConfig.createRuntimeConfig(application);
Errors.processWithException(
new Runnable() {
@Override
public void run() {
initialize();
}
});
}
/**
* Create a new Jersey server-side application handler configured by an instance of a {@link
* Application JAX-RS Application sub-class}.
*
* @param application an instance of a JAX-RS {@code Application} (sub-)class that will be used to
* configure the new Jersey application handler.
*/
public ApplicationHandler(Application application) {
this.locator = Injections.createLocator(new ServerBinder(), new ApplicationBinder());
this.application = application;
if (application instanceof ResourceConfig) {
final ResourceConfig rc = (ResourceConfig) application;
if (rc.getApplicationClass() != null) {
rc.setApplication(createApplication(rc.getApplicationClass()));
}
}
this.runtimeConfig = ResourceConfig.createRuntimeConfig(application);
Errors.processWithException(
new Runnable() {
@Override
public void run() {
initialize();
}
});
}
@SuppressWarnings({"unchecked", "rawtypes"})
public Task<Void> start() {
// Ensuring that jersey will use singletons from the orbit container.
ServiceLocator locator = Injections.createLocator();
DynamicConfigurationService dcs = locator.getService(DynamicConfigurationService.class);
DynamicConfiguration dc = dcs.createDynamicConfiguration();
final List<Class<?>> classes = new ArrayList<>(providers);
if (container != null) {
classes.addAll(container.getClasses());
for (final Class<?> c : container.getClasses()) {
if (c.isAnnotationPresent(Singleton.class)) {
Injections.addBinding(
Injections.newFactoryBinder(
new Factory() {
@Override
public Object provide() {
return container.get(c);
}
@Override
public void dispose(final Object instance) {}
})
.to(c),
dc);
}
}
}
dc.commit();
final ResourceConfig resourceConfig = new ResourceConfig();
// installing jax-rs classes known by the orbit container.
for (final Class c : classes) {
if (c.isAnnotationPresent(javax.ws.rs.Path.class)
|| c.isAnnotationPresent(javax.ws.rs.ext.Provider.class)) {
resourceConfig.register(c);
}
}
final WebAppContext webAppContext = new WebAppContext();
final ProtectionDomain protectionDomain = EmbeddedHttpServer.class.getProtectionDomain();
final URL location = protectionDomain.getCodeSource().getLocation();
logger.info(location.toExternalForm());
webAppContext.setInitParameter("useFileMappedBuffer", "false");
webAppContext.setWar(location.toExternalForm());
// this sets the default service locator to one that bridges to the orbit container.
webAppContext.getServletContext().setAttribute(ServletProperties.SERVICE_LOCATOR, locator);
webAppContext.setContextPath("/*");
webAppContext.addServlet(new ServletHolder(new ServletContainer(resourceConfig)), "/*");
final ContextHandler resourceContext = new ContextHandler();
ResourceHandler resourceHandler = new ResourceHandler();
resourceHandler.setDirectoriesListed(true);
resourceHandler.setWelcomeFiles(new String[] {"index.html"});
resourceHandler.setBaseResource(Resource.newClassPathResource("/web"));
resourceContext.setHandler(resourceHandler);
resourceContext.setInitParameter("useFileMappedBuffer", "false");
final ContextHandlerCollection contexts = new ContextHandlerCollection();
contexts.setHandlers(
new Handler[] {
wrapHandlerWithMetrics(resourceContext, "resourceContext"),
wrapHandlerWithMetrics(webAppContext, "webAppContext")
});
server = new Server(port);
server.setHandler(contexts);
try {
/// Initialize javax.websocket layer
final ServerContainer serverContainer =
WebSocketServerContainerInitializer.configureContext(webAppContext);
for (Class c : classes) {
if (c.isAnnotationPresent(ServerEndpoint.class)) {
final ServerEndpoint annotation = (ServerEndpoint) c.getAnnotation(ServerEndpoint.class);
final ServerEndpointConfig serverEndpointConfig =
ServerEndpointConfig.Builder.create(c, annotation.value())
.configurator(
new ServerEndpointConfig.Configurator() {
@Override
public <T> T getEndpointInstance(final Class<T> endpointClass)
throws InstantiationException {
return container.get(endpointClass);
}
})
.build();
serverContainer.addEndpoint(serverEndpointConfig);
}
}
} catch (Exception e) {
logger.error("Error starting jetty", e);
throw new UncheckedException(e);
}
try {
server.start();
} catch (Exception e) {
logger.error("Error starting jetty", e);
throw new UncheckedException(e);
}
return Task.done();
}
private void bindProvidersAndResources(
final Set<ComponentProvider> componentProviders,
final ComponentBag componentBag,
final Set<Class<?>> resourceClasses,
final Set<Object> resourceInstances) {
final JerseyResourceContext resourceContext = locator.getService(JerseyResourceContext.class);
final DynamicConfiguration dc = Injections.getConfiguration(locator);
final Set<Class<?>> registeredClasses = runtimeConfig.getRegisteredClasses();
// Merge programmatic resource classes with component classes.
Set<Class<?>> classes = Sets.newIdentityHashSet();
classes.addAll(
Sets.filter(
componentBag.getClasses(ComponentBag.EXCLUDE_META_PROVIDERS),
new Predicate<Class<?>>() {
@Override
public boolean apply(Class<?> componentClass) {
return Providers.checkProviderRuntime(
componentClass,
componentBag.getModel(componentClass),
RuntimeType.SERVER,
!registeredClasses.contains(componentClass),
resourceClasses.contains(componentClass));
}
}));
classes.addAll(resourceClasses);
// Bind classes.
for (Class<?> componentClass : classes) {
ContractProvider model = componentBag.getModel(componentClass);
if (resourceClasses.contains(componentClass)) {
if (bindWithComponentProvider(componentClass, model, componentProviders)) {
continue;
}
if (!Resource.isAcceptable(componentClass)) {
LOGGER.warning(LocalizationMessages.NON_INSTANTIABLE_COMPONENT(componentClass));
continue;
}
if (model != null
&& !Providers.checkProviderRuntime(
componentClass,
model,
RuntimeType.SERVER,
!registeredClasses.contains(componentClass),
true)) {
model = null;
}
resourceContext.unsafeBindResource(componentClass, model, dc);
} else {
ProviderBinder.bindProvider(componentClass, model, dc);
}
}
// Merge programmatic resource instances with other component instances.
Set<Object> instances = Sets.newHashSet();
instances.addAll(
Sets.filter(
componentBag.getInstances(ComponentBag.EXCLUDE_META_PROVIDERS),
new Predicate<Object>() {
@Override
public boolean apply(Object component) {
final Class<?> componentClass = component.getClass();
return Providers.checkProviderRuntime(
componentClass,
componentBag.getModel(componentClass),
RuntimeType.SERVER,
!registeredClasses.contains(componentClass),
resourceInstances.contains(component));
}
}));
instances.addAll(resourceInstances);
// Bind instances.
for (Object component : instances) {
ContractProvider model = componentBag.getModel(component.getClass());
if (resourceInstances.contains(component)) {
if (model != null
&& !Providers.checkProviderRuntime(
component.getClass(),
model,
RuntimeType.SERVER,
!registeredClasses.contains(component.getClass()),
true)) {
model = null;
}
resourceContext.unsafeBindResource(component, model, dc);
} else {
ProviderBinder.bindProvider(component, model, dc);
}
}
dc.commit();
}