/**
* Attaches a JAX-RS {@link Application} to this JaxRsApplication.<br>
* The providers are available for all root resource classes provided to this JaxRsApplication. If
* you won't mix them, instantiate another JaxRsApplication.
*
* @param appConfig Contains the classes to load as root resource classes and as providers.
* Invalid root resource classes and provider classes are ignored, according to JAX-RS
* specification.
* @return true, if all resource classes and providers could be added, or false at least one could
* not be added. Exceptions were logged.
* @throws IllegalArgumentException if the given appConfig is null.
*/
public boolean add(Application appConfig) throws IllegalArgumentException {
if (appConfig == null) {
throw new IllegalArgumentException("The ApplicationConfig must not be null");
}
JaxRsRestlet jaxRsRestlet = this.jaxRsRestlet;
boolean everythingFine = true;
if (jaxRsRestlet == null) {
everythingFine = false;
getLogger().warning("No JAX-RS to Restlet adapter available to handle to calls.");
} else {
Set<Class<?>> classes = appConfig.getClasses();
Set<Object> singletons = appConfig.getSingletons();
if (singletons != null) {
for (Object singleton : singletons) {
// LATER test: check, if a singleton is also available in
// the
// classes -> ignore or whatever
if (singleton != null && !classes.contains(singleton.getClass())) {
everythingFine &= jaxRsRestlet.addSingleton(singleton);
}
}
}
if (classes != null) {
for (Class<?> clazz : classes) {
everythingFine &= jaxRsRestlet.addClass(clazz);
}
}
}
return everythingFine;
}
public void publish(Application application) {
Set<Class<?>> classes = new LinkedHashSet<>();
Set<Class<?>> appClasses = application.getClasses();
if (appClasses != null) {
classes.addAll(appClasses);
}
if (application instanceof EverrestApplication) {
EverrestApplication everrest = (EverrestApplication) application;
for (Map.Entry<String, Class<?>> e : everrest.getResourceClasses().entrySet()) {
Class<?> clazz = e.getValue();
addResource(e.getKey(), clazz);
classes.remove(clazz);
}
for (Map.Entry<String, Object> e : everrest.getResourceSingletons().entrySet()) {
addResource(e.getKey(), e.getValue());
}
for (ObjectFactory<? extends ObjectModel> factory : everrest.getFactories()) {
addFactory(factory);
classes.remove(factory.getObjectModel().getObjectClass());
}
}
for (Class<?> clazz : classes) {
addPerRequest(clazz);
}
Set<Object> singletons = application.getSingletons();
if (singletons != null) {
for (Object instance : singletons) {
addSingleton(instance);
}
}
}
@GET
public String get() {
assertTrue(application != null);
assertTrue(application.getClasses().contains(ResourceB.class));
assertTrue(application.getSingletons().size() > 0);
assertTrue(
application.getSingletons().iterator().next().getClass().equals(ResourceAReader.class));
return "get!";
}
@Test
public void callsPreDestroyMethodsForSingletonComponentsOnStop() throws Exception {
EchoResource resource = new EchoResource();
Application application = mock(Application.class);
when(application.getSingletons()).thenReturn(newHashSet(resource));
when(requestHandler.getResources()).thenReturn(mock(ResourceBinder.class));
everrestProcessor.addApplication(application);
everrestProcessor.stop();
assertEquals(1, resource.preDestroyActionInvocationsCounter.get());
}
@Test
public void addsClassesFromNewApplicationToTheBeginningOfSetOfClasses() {
Application applicationOne = mock(Application.class);
Application applicationTwo = mock(Application.class);
when(applicationOne.getClasses()).thenReturn(newHashSet(ResourceOne.class));
when(applicationTwo.getClasses()).thenReturn(newHashSet(ResourceTwo.class));
everrestApplication.addApplication(applicationTwo);
assertEquals(newHashSet(ResourceTwo.class), everrestApplication.getClasses());
everrestApplication.addApplication(applicationOne);
assertEquals(
newHashSet(ResourceOne.class, ResourceTwo.class), everrestApplication.getClasses());
}
@Test
public void addsSingletonsFromNewApplicationToTheBeginningOfSetOfSingletons() {
Application applicationOne = mock(Application.class);
Application applicationTwo = mock(Application.class);
ResourceOne resourceOne = new ResourceOne();
ResourceTwo resourceTwo = new ResourceTwo();
when(applicationOne.getSingletons()).thenReturn(newHashSet(resourceOne));
when(applicationTwo.getSingletons()).thenReturn(newHashSet(resourceTwo));
everrestApplication.addApplication(applicationTwo);
assertEquals(newHashSet(resourceTwo), everrestApplication.getSingletons());
everrestApplication.addApplication(applicationOne);
assertEquals(newHashSet(resourceOne, resourceTwo), everrestApplication.getSingletons());
}
public static List<String> getPaths(Application application) {
List<String> paths = new ArrayList<String>();
Set<Class<?>> clazzes = application.getClasses();
for (Class<?> clazz : clazzes) {
paths.addAll(getPaths(clazz));
}
Set<Object> singletons = application.getSingletons();
for (Object object : singletons) {
paths.addAll(getPaths(object.getClass()));
}
return paths;
}
private RSDL getRSDL(Application application) throws ClassNotFoundException, IOException {
RSDL rsdl = null;
for (Object obj : application.getSingletons()) {
if (obj instanceof BackendApiResource) {
BackendApiResource resource = (BackendApiResource) obj;
rsdl = resource.getRSDL();
break;
}
}
assert (rsdl != null)
: "Resource that generates RSDL, BackendApiResource, not found (this should never happen)";
return rsdl;
}
@SuppressWarnings("unchecked")
public static JAXRSServerFactoryBean createApplication(
Application app, boolean ignoreAppPath, boolean staticSubresourceResolution) {
Set<Object> singletons = app.getSingletons();
verifySingletons(singletons);
List<Class<?>> resourceClasses = new ArrayList<Class<?>>();
List<Object> providers = new ArrayList<Object>();
List<Feature> features = new ArrayList<Feature>();
Map<Class<?>, ResourceProvider> map = new HashMap<Class<?>, ResourceProvider>();
// Note, app.getClasses() returns a list of per-request classes
// or singleton provider classes
for (Class<?> cls : app.getClasses()) {
if (isValidApplicationClass(cls, singletons)) {
if (isValidProvider(cls)) {
providers.add(createProviderInstance(cls));
} else if (Feature.class.isAssignableFrom(cls)) {
features.add(createFeatureInstance((Class<? extends Feature>) cls));
} else {
resourceClasses.add(cls);
map.put(cls, new PerRequestResourceProvider(cls));
}
}
}
// we can get either a provider or resource class here
for (Object o : singletons) {
if (isValidProvider(o.getClass())) {
providers.add(o);
} else if (o instanceof Feature) {
features.add((Feature) o);
} else {
resourceClasses.add(o.getClass());
map.put(o.getClass(), new SingletonResourceProvider(o));
}
}
JAXRSServerFactoryBean bean = new JAXRSServerFactoryBean();
String address = "/";
if (!ignoreAppPath) {
ApplicationPath appPath = app.getClass().getAnnotation(ApplicationPath.class);
if (appPath != null) {
address = appPath.value();
}
}
if (!address.startsWith("/")) {
address = "/" + address;
}
bean.setAddress(address);
bean.setStaticSubresourceResolution(staticSubresourceResolution);
bean.setResourceClasses(resourceClasses);
bean.setProviders(providers);
bean.setFeatures(features);
for (Map.Entry<Class<?>, ResourceProvider> entry : map.entrySet()) {
bean.setResourceProvider(entry.getKey(), entry.getValue());
}
Map<String, Object> appProps = app.getProperties();
if (appProps != null) {
bean.getProperties(true).putAll(appProps);
}
bean.setApplication(app);
return bean;
}
/** Assumes the configuration field is initialized with a valid ResourceConfig. */
private void initialize() {
LOGGER.info(LocalizationMessages.INIT_MSG(Version.getBuildId()));
// Lock original ResourceConfig.
if (application instanceof ResourceConfig) {
((ResourceConfig) application).lock();
}
// add WADL support
runtimeConfig.register(WadlModelProcessorFeature.class);
// Configure binders and features.
runtimeConfig.configureMetaProviders(locator);
// Introspecting classes & instances
final ResourceBag.Builder resourceBagBuilder = new ResourceBag.Builder();
for (Class<?> c : runtimeConfig.getClasses()) {
try {
Resource resource = Resource.from(c);
if (resource != null) {
resourceBagBuilder.registerResource(c, resource);
}
} catch (IllegalArgumentException ex) {
LOGGER.warning(ex.getMessage());
}
}
for (Object o : runtimeConfig.getSingletons()) {
try {
Resource resource = Resource.from(o.getClass());
if (resource != null) {
resourceBagBuilder.registerResource(o, resource);
}
} catch (IllegalArgumentException ex) {
LOGGER.warning(ex.getMessage());
}
}
// Adding programmatic resource models
for (Resource programmaticResource : runtimeConfig.getResources()) {
resourceBagBuilder.registerProgrammaticResource(programmaticResource);
}
final ResourceBag resourceBag = resourceBagBuilder.build();
runtimeConfig.lock();
// Registering Injection Bindings
final Set<ComponentProvider> componentProviders = new HashSet<ComponentProvider>();
for (ComponentProvider provider : ServiceFinder.find(ComponentProvider.class)) {
provider.initialize(locator);
componentProviders.add(provider);
}
final ComponentBag componentBag = runtimeConfig.getComponentBag();
bindProvidersAndResources(
componentProviders, componentBag, resourceBag.classes, resourceBag.instances);
for (ComponentProvider componentProvider : componentProviders) {
componentProvider.done();
}
// scan for NameBinding annotations attached to the application class
Collection<Class<? extends Annotation>> applicationNameBindings =
ReflectionHelper.getAnnotationTypes(application.getClass(), NameBinding.class);
// find all filters, interceptors and dynamic features
final Iterable<RankedProvider<ContainerResponseFilter>> responseFilters =
Providers.getAllRankedProviders(locator, ContainerResponseFilter.class);
final MultivaluedMap<Class<? extends Annotation>, RankedProvider<ContainerResponseFilter>>
nameBoundResponseFilters =
filterNameBound(responseFilters, null, componentBag, applicationNameBindings);
final Iterable<RankedProvider<ContainerRequestFilter>> requestFilters =
Providers.getAllRankedProviders(locator, ContainerRequestFilter.class);
final List<RankedProvider<ContainerRequestFilter>> preMatchFilters = Lists.newArrayList();
final MultivaluedMap<Class<? extends Annotation>, RankedProvider<ContainerRequestFilter>>
nameBoundRequestFilters =
filterNameBound(requestFilters, preMatchFilters, componentBag, applicationNameBindings);
final Iterable<RankedProvider<ReaderInterceptor>> readerInterceptors =
Providers.getAllRankedProviders(locator, ReaderInterceptor.class);
final MultivaluedMap<Class<? extends Annotation>, RankedProvider<ReaderInterceptor>>
nameBoundReaderInterceptors =
filterNameBound(readerInterceptors, null, componentBag, applicationNameBindings);
final Iterable<RankedProvider<WriterInterceptor>> writerInterceptors =
Providers.getAllRankedProviders(locator, WriterInterceptor.class);
final MultivaluedMap<Class<? extends Annotation>, RankedProvider<WriterInterceptor>>
nameBoundWriterInterceptors =
filterNameBound(writerInterceptors, null, componentBag, applicationNameBindings);
final Iterable<DynamicFeature> dynamicFeatures =
Providers.getAllProviders(locator, DynamicFeature.class);
ResourceModel resourceModel =
new ResourceModel.Builder(resourceBag.getRootResources(), false).build();
resourceModel = processResourceModel(resourceModel);
// validate the models
validate(resourceModel);
bindEnhancingResourceClasses(resourceModel, resourceBag, componentProviders);
final RuntimeModelBuilder runtimeModelBuilder = locator.getService(RuntimeModelBuilder.class);
runtimeModelBuilder.setGlobalInterceptors(readerInterceptors, writerInterceptors);
runtimeModelBuilder.setBoundProviders(
nameBoundRequestFilters,
nameBoundResponseFilters,
nameBoundReaderInterceptors,
nameBoundWriterInterceptors,
dynamicFeatures);
// assembly request processing chain
/**
* Root hierarchical request matching acceptor. Invoked in a single linear stage as part of the
* main linear accepting chain.
*/
final Router resourceRoutingRoot =
runtimeModelBuilder.buildModel(resourceModel.getRuntimeResourceModel(), false);
final ContainerFilteringStage preMatchRequestFilteringStage =
locator
.createAndInitialize(ContainerFilteringStage.Builder.class)
.build(preMatchFilters, responseFilters);
final RoutingStage routingStage =
locator.createAndInitialize(RoutingStage.Builder.class).build(resourceRoutingRoot);
final ContainerFilteringStage resourceFilteringStage =
locator
.createAndInitialize(ContainerFilteringStage.Builder.class)
.build(requestFilters, null);
final RoutedInflectorExtractorStage routedInflectorExtractorStage =
locator.createAndInitialize(RoutedInflectorExtractorStage.class);
/**
* Root linear request acceptor. This is the main entry point for the whole request processing.
*/
final Stage<ContainerRequest> rootStage =
Stages.chain(locator.createAndInitialize(ReferencesInitializer.class))
.to(locator.createAndInitialize(ContainerMessageBodyWorkersInitializer.class))
.to(preMatchRequestFilteringStage)
.to(routingStage)
.to(resourceFilteringStage)
.build(routedInflectorExtractorStage);
// Inject instances.
for (Object instance : componentBag.getInstances(ComponentBag.EXCLUDE_META_PROVIDERS)) {
locator.inject(instance);
}
for (Object instance : resourceBag.instances) {
locator.inject(instance);
}
// initiate resource model into JerseyResourceContext
JerseyResourceContext jerseyResourceContext = locator.getService(JerseyResourceContext.class);
jerseyResourceContext.setResourceModel(resourceModel);
this.runtime = locator.createAndInitialize(ServerRuntime.Builder.class).build(rootStage);
// inject self
locator.inject(this);
}
public AuthorResource(@Context Application app) throws Exception {
_authorDao = (AuthorDao) app.getProperties().get("authorDao");
logger.info("Using AuthorDao implementation " + _authorDao.getClass().getSimpleName());
}