All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.jboss.resteasy.spi.ResteasyDeployment Maven / Gradle / Ivy
package org.jboss.resteasy.spi;
import org.jboss.resteasy.core.AcceptHeaderByFileSuffixFilter;
import org.jboss.resteasy.core.AcceptParameterHttpPreprocessor;
import org.jboss.resteasy.core.AsynchronousDispatcher;
import org.jboss.resteasy.core.Dispatcher;
import org.jboss.resteasy.core.ResourceMethodRegistry;
import org.jboss.resteasy.core.SynchronousDispatcher;
import org.jboss.resteasy.core.ThreadLocalResteasyProviderFactory;
import org.jboss.resteasy.plugins.interceptors.RoleBasedSecurityFeature;
import org.jboss.resteasy.plugins.providers.RegisterBuiltin;
import org.jboss.resteasy.plugins.providers.ServerFormUrlEncodedProvider;
import org.jboss.resteasy.plugins.server.resourcefactory.JndiComponentResourceFactory;
import org.jboss.resteasy.plugins.server.servlet.ResteasyContextParameters;
import org.jboss.resteasy.resteasy_jaxrs.i18n.LogMessages;
import org.jboss.resteasy.resteasy_jaxrs.i18n.Messages;
import org.jboss.resteasy.util.GetRestful;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.Configurable;
import javax.ws.rs.core.Configuration;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.ext.Providers;
import javax.ws.rs.core.Feature;
import javax.ws.rs.core.FeatureContext;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* This class is used to configure and initialize the core components of RESTEasy.
*
* @author Bill Burke
* @version $Revision: 1 $
*/
public class ResteasyDeployment
{
private boolean widerRequestMatching;
private boolean useContainerFormParams = false;
private boolean deploymentSensitiveFactoryEnabled = false;
private boolean asyncJobServiceEnabled = false;
private boolean addCharset = true;
private int asyncJobServiceMaxJobResults = 100;
private long asyncJobServiceMaxWait = 300000;
private int asyncJobServiceThreadPoolSize = 100;
private String asyncJobServiceBasePath = "/asynch/jobs";
private String applicationClass;
private String injectorFactoryClass;
private InjectorFactory injectorFactory;
private Application application;
private boolean registerBuiltin = true;
private List scannedResourceClasses = new ArrayList();
private List scannedProviderClasses = new ArrayList();
private List scannedJndiComponentResources = new ArrayList();
private List jndiComponentResources = new ArrayList();
private List providerClasses = new ArrayList();
private List actualProviderClasses = new ArrayList();
private List providers = new ArrayList();
private boolean securityEnabled = false;
private List jndiResources = new ArrayList();
private List resourceClasses = new ArrayList();
private List unwrappedExceptions = new ArrayList();
private List actualResourceClasses = new ArrayList();
private List resourceFactories = new ArrayList();
private List resources = new ArrayList();
private Map mediaTypeMappings = new HashMap();
private Map languageExtensions = new HashMap();
private Map defaultContextObjects = new HashMap();
private Map constructedDefaultContextObjects = new HashMap();
private Registry registry;
private Dispatcher dispatcher;
private ResteasyProviderFactory providerFactory;
private ThreadLocalResteasyProviderFactory threadLocalProviderFactory;
private String paramMapping;
public void start()
{
try
{
startInternal();
}
finally
{
ThreadLocalResteasyProviderFactory.pop();
}
}
@SuppressWarnings(value = {"unchecked", "deprecation"})
private void startInternal()
{
// it is very important that each deployment create their own provider factory
// this allows each WAR to have their own set of providers
if (providerFactory == null) providerFactory = ResteasyProviderFactory.newInstance();
providerFactory.setRegisterBuiltins(registerBuiltin);
Object tracingText;
Object thresholdText;
tracingText = System.getProperty(ResteasyContextParameters.RESTEASY_TRACING_TYPE);
thresholdText = System.getProperty(ResteasyContextParameters.RESTEASY_TRACING_THRESHOLD);
Object context = getDefaultContextObjects().get(ResteasyConfiguration.class);
if (tracingText != null) {
providerFactory.property(ResteasyContextParameters.RESTEASY_TRACING_TYPE, tracingText);
} else {
if (context != null) {
tracingText = ((ResteasyConfiguration) context).getParameter(ResteasyContextParameters.RESTEASY_TRACING_TYPE);
if (tracingText != null) {
providerFactory.property(ResteasyContextParameters.RESTEASY_TRACING_TYPE, tracingText);
}
}
}
if (thresholdText != null) {
providerFactory.getMutableProperties().put(ResteasyContextParameters.RESTEASY_TRACING_THRESHOLD, thresholdText);
} else {
if (context != null) {
thresholdText = ((ResteasyConfiguration) context).getInitParameter(ResteasyContextParameters.RESTEASY_TRACING_THRESHOLD);
if (thresholdText != null) {
providerFactory.getMutableProperties().put(ResteasyContextParameters.RESTEASY_TRACING_THRESHOLD, thresholdText);
}
}
}
if (deploymentSensitiveFactoryEnabled)
{
// the ThreadLocalResteasyProviderFactory pushes and pops this deployments parentProviderFactory
// on a ThreadLocal stack. This allows each application/WAR to have their own parentProviderFactory
// and still be able to call ResteasyProviderFactory.getInstance()
if (!(providerFactory instanceof ThreadLocalResteasyProviderFactory))
{
if (ResteasyProviderFactory.peekInstance() == null || !(ResteasyProviderFactory.peekInstance() instanceof ThreadLocalResteasyProviderFactory))
{
threadLocalProviderFactory = new ThreadLocalResteasyProviderFactory(providerFactory);
ResteasyProviderFactory.setInstance(threadLocalProviderFactory);
}
else
{
ThreadLocalResteasyProviderFactory.push(providerFactory);
}
}
else
{
ThreadLocalResteasyProviderFactory.push(providerFactory);
}
}
else
{
ResteasyProviderFactory.setInstance(providerFactory);
}
if (asyncJobServiceEnabled)
{
AsynchronousDispatcher asyncDispatcher;
if (dispatcher == null) {
asyncDispatcher = new AsynchronousDispatcher(providerFactory);
dispatcher = asyncDispatcher;
} else {
asyncDispatcher = (AsynchronousDispatcher) dispatcher;
}
asyncDispatcher.setMaxCacheSize(asyncJobServiceMaxJobResults);
asyncDispatcher.setMaxWaitMilliSeconds(asyncJobServiceMaxWait);
asyncDispatcher.setThreadPoolSize(asyncJobServiceThreadPoolSize);
asyncDispatcher.setBasePath(asyncJobServiceBasePath);
asyncDispatcher.getUnwrappedExceptions().addAll(unwrappedExceptions);
asyncDispatcher.start();
}
else
{
SynchronousDispatcher dis;
if (dispatcher == null) {
dis = new SynchronousDispatcher(providerFactory);
dispatcher = dis;
} else {
dis = (SynchronousDispatcher) dispatcher;
}
dis.getUnwrappedExceptions().addAll(unwrappedExceptions);
}
registry = dispatcher.getRegistry();
if (widerRequestMatching)
{
((ResourceMethodRegistry)registry).setWiderMatching(widerRequestMatching);
}
dispatcher.getDefaultContextObjects().putAll(defaultContextObjects);
dispatcher.getDefaultContextObjects().put(Configurable.class, providerFactory);
dispatcher.getDefaultContextObjects().put(Configuration.class, providerFactory);
dispatcher.getDefaultContextObjects().put(Providers.class, providerFactory);
dispatcher.getDefaultContextObjects().put(Registry.class, registry);
dispatcher.getDefaultContextObjects().put(Dispatcher.class, dispatcher);
dispatcher.getDefaultContextObjects().put(InternalDispatcher.class, InternalDispatcher.getInstance());
dispatcher.getDefaultContextObjects().put(ResteasyDeployment.class, this);
// push context data so we can inject it
Map contextDataMap = ResteasyProviderFactory.getContextDataMap();
contextDataMap.putAll(dispatcher.getDefaultContextObjects());
try
{
if (injectorFactory == null && injectorFactoryClass != null)
{
try
{
Class clazz = Thread.currentThread().getContextClassLoader().loadClass(injectorFactoryClass);
injectorFactory = (InjectorFactory) clazz.newInstance();
}
catch (ClassNotFoundException cnfe)
{
throw new RuntimeException(Messages.MESSAGES.unableToFindInjectorFactory(), cnfe);
}
catch (Exception e)
{
throw new RuntimeException(Messages.MESSAGES.unableToInstantiateInjectorFactory(), e);
}
}
if (injectorFactory != null)
{
providerFactory.setInjectorFactory(injectorFactory);
}
// feed context data map with constructed objects
// see ResteasyContextParameters.RESTEASY_CONTEXT_OBJECTS
if (constructedDefaultContextObjects != null && constructedDefaultContextObjects.size() > 0)
{
for (Map.Entry entry : constructedDefaultContextObjects.entrySet())
{
Class key = null;
try
{
key = Thread.currentThread().getContextClassLoader().loadClass(entry.getKey());
}
catch (ClassNotFoundException e)
{
throw new RuntimeException(Messages.MESSAGES.unableToInstantiateContextObject(entry.getKey()), e);
}
Object obj = createFromInjectorFactory(entry.getValue(), providerFactory);
LogMessages.LOGGER.creatingContextObject(entry.getKey(), entry.getValue());
defaultContextObjects.put(key, obj);
dispatcher.getDefaultContextObjects().put(key, obj);
contextDataMap.put(key, obj);
}
}
if (securityEnabled)
{
providerFactory.register(RoleBasedSecurityFeature.class);
}
if (registerBuiltin)
{
providerFactory.setRegisterBuiltins(true);
RegisterBuiltin.register(providerFactory);
// having problems using form parameters from container for a couple of TCK tests. I couldn't figure out
// why, specifically:
// com/sun/ts/tests/jaxrs/spec/provider/standardhaspriority/JAXRSClient.java#readWriteMapProviderTest_from_standalone Failed. Test case throws exception: [JAXRSCommonClient] null failed! Check output for cause of failure.
// com/sun/ts/tests/jaxrs/spec/provider/standardwithjaxrsclient/JAXRSClient.java#mapElementProviderTest_from_standalone Failed. Test case throws exception: returned MultivaluedMap is null
providerFactory.registerProviderInstance(new ServerFormUrlEncodedProvider(useContainerFormParams), null, null, true);
}
else
{
providerFactory.setRegisterBuiltins(false);
}
if (applicationClass != null)
{
application = createApplication(applicationClass, dispatcher, providerFactory);
}
// register all providers
registration();
if (paramMapping != null)
{
providerFactory.getContainerRequestFilterRegistry().registerSingleton(new AcceptParameterHttpPreprocessor(paramMapping));
}
AcceptHeaderByFileSuffixFilter suffixNegotiationFilter = null;
if (mediaTypeMappings != null)
{
Map extMap = new HashMap();
for (Map.Entry ext : mediaTypeMappings.entrySet())
{
String value = ext.getValue();
extMap.put(ext.getKey().trim(), MediaType.valueOf(value.trim()));
}
if (suffixNegotiationFilter == null)
{
suffixNegotiationFilter = new AcceptHeaderByFileSuffixFilter();
providerFactory.getContainerRequestFilterRegistry().registerSingleton(suffixNegotiationFilter);
}
suffixNegotiationFilter.setMediaTypeMappings(extMap);
}
if (languageExtensions != null)
{
if (suffixNegotiationFilter == null)
{
suffixNegotiationFilter = new AcceptHeaderByFileSuffixFilter();
providerFactory.getContainerRequestFilterRegistry().registerSingleton(suffixNegotiationFilter);
}
suffixNegotiationFilter.setLanguageMappings(languageExtensions);
}
}
finally
{
ResteasyProviderFactory.removeContextDataLevel();
}
}
public void merge(ResteasyDeployment other)
{
scannedResourceClasses.addAll(other.getScannedResourceClasses());
scannedProviderClasses.addAll(other.getScannedProviderClasses());
scannedJndiComponentResources.addAll(other.getScannedJndiComponentResources());
jndiComponentResources.addAll(other.getJndiComponentResources());
providerClasses.addAll(other.getProviderClasses());
actualProviderClasses.addAll(other.getActualProviderClasses());
providers.addAll(other.getProviders());
jndiResources.addAll(other.getJndiResources());
resourceClasses.addAll(other.getResourceClasses());
unwrappedExceptions.addAll(other.getUnwrappedExceptions());
actualResourceClasses.addAll(other.getActualResourceClasses());
resourceFactories.addAll(other.getResourceFactories());
resources.addAll(other.getResources());
mediaTypeMappings.putAll(other.getMediaTypeMappings());
languageExtensions.putAll(other.getLanguageExtensions());
defaultContextObjects.putAll(other.getDefaultContextObjects());
constructedDefaultContextObjects.putAll(other.getConstructedDefaultContextObjects());
}
public static Application createApplication(String applicationClass, Dispatcher dispatcher, ResteasyProviderFactory providerFactory)
{
Class clazz = null;
try
{
clazz = Thread.currentThread().getContextClassLoader().loadClass(applicationClass);
}
catch (ClassNotFoundException e)
{
throw new RuntimeException(e);
}
Application app = (Application)providerFactory.createProviderInstance(clazz);
dispatcher.getDefaultContextObjects().put(Application.class, app);
ResteasyProviderFactory.pushContext(Application.class, app);
PropertyInjector propertyInjector = providerFactory.getInjectorFactory().createPropertyInjector(clazz, providerFactory);
propertyInjector.inject(app, false);
return app;
}
private static Object createFromInjectorFactory(String classname, ResteasyProviderFactory providerFactory)
{
Class clazz = null;
try
{
clazz = Thread.currentThread().getContextClassLoader().loadClass(classname);
}
catch (ClassNotFoundException e)
{
throw new RuntimeException(e);
}
Object obj = providerFactory.injectedInstance(clazz);
return obj;
}
public void registration()
{
boolean useScanning = true;
if (application != null)
{
dispatcher.getDefaultContextObjects().put(Application.class, application);
ResteasyProviderFactory.getContextDataMap().put(Application.class, application);
if (processApplication(application))
{
// Application class registered something so don't use scanning data. See JAX-RS spec for more detail.
useScanning = false;
}
}
if (useScanning && scannedProviderClasses != null)
{
for (String provider : scannedProviderClasses)
{
registerProvider(provider);
}
}
if (providerClasses != null)
{
for (String provider : providerClasses)
{
registerProvider(provider);
}
}
if (providers != null)
{
for (Object provider : providers)
{
providerFactory.registerProviderInstance(provider);
}
}
for (Class actualProviderClass : actualProviderClasses)
{
providerFactory.registerProvider(actualProviderClass);
}
// All providers should be registered before resources because of interceptors.
// interceptors must exist as they are applied only once when the resource is registered.
if (useScanning && scannedJndiComponentResources != null)
{
for (String resource : scannedJndiComponentResources)
{
registerJndiComponentResource(resource);
}
}
if (jndiComponentResources != null)
{
for (String resource : jndiComponentResources)
{
registerJndiComponentResource(resource);
}
}
if (jndiResources != null)
{
for (String resource : jndiResources)
{
registry.addJndiResource(resource.trim());
}
}
if (useScanning && scannedResourceClasses != null)
{
for (String resource : scannedResourceClasses)
{
Class clazz = null;
try
{
clazz = Thread.currentThread().getContextClassLoader().loadClass(resource.trim());
}
catch (ClassNotFoundException e)
{
throw new RuntimeException(e);
}
registry.addPerRequestResource(clazz);
}
}
if (resourceClasses != null)
{
for (String resource : resourceClasses)
{
Class clazz = null;
try
{
clazz = Thread.currentThread().getContextClassLoader().loadClass(resource.trim());
}
catch (ClassNotFoundException e)
{
throw new RuntimeException(e);
}
registry.addPerRequestResource(clazz);
}
}
if (resources != null)
{
for (Object obj : resources)
{
registry.addSingletonResource(obj);
}
}
for (Class actualResourceClass : actualResourceClasses)
{
registry.addPerRequestResource(actualResourceClass);
}
for (ResourceFactory factory : resourceFactories)
{
registry.addResourceFactory(factory);
}
registry.checkAmbiguousUri();
}
private void registerJndiComponentResource(String resource)
{
String[] config = resource.trim().split(";");
if (config.length < 3)
{
throw new RuntimeException(Messages.MESSAGES.jndiComponentResourceNotSetCorrectly());
}
String jndiName = config[0];
Class clazz = null;
try
{
clazz = Thread.currentThread().getContextClassLoader().loadClass(config[1]);
}
catch (ClassNotFoundException e)
{
throw new RuntimeException(Messages.MESSAGES.couldNotFindClassJndi(config[1]), e);
}
boolean cacheRefrence = Boolean.valueOf(config[2].trim());
JndiComponentResourceFactory factory = new JndiComponentResourceFactory(jndiName, clazz, cacheRefrence);
getResourceFactories().add(factory);
}
public void stop()
{
if (asyncJobServiceEnabled)
{
((AsynchronousDispatcher) dispatcher).stop();
}
ResteasyProviderFactory.clearInstanceIfEqual(threadLocalProviderFactory);
ResteasyProviderFactory.clearInstanceIfEqual(providerFactory);
}
/**
* @param config application
* @return whether application class registered anything. i.e. whether scanning metadata should be used or not
*/
private boolean processApplication(Application config)
{
LogMessages.LOGGER.deployingApplication(Application.class.getName(), config.getClass());
boolean registered = false;
if (config.getClasses() != null)
{
for (Class clazz : config.getClasses())
{
if (GetRestful.isRootResource(clazz))
{
LogMessages.LOGGER.addingClassResource(clazz.getName(), config.getClass());
actualResourceClasses.add(clazz);
registered = true;
}
else
{
LogMessages.LOGGER.addingProviderClass(clazz.getName(), config.getClass());
actualProviderClasses.add(clazz);
registered = true;
}
}
}
if (config.getSingletons() != null)
{
for (Object obj : config.getSingletons())
{
if (GetRestful.isRootResource(obj.getClass()))
{
if (actualResourceClasses.contains(obj.getClass()))
{
LogMessages.LOGGER.singletonClassAlreadyDeployed("resource", obj.getClass().getName());
}
else
{
LogMessages.LOGGER.addingSingletonResource(obj.getClass().getName(), config.getClass());
resources.add(obj);
registered = true;
}
}
else
{
if (actualProviderClasses.contains(obj.getClass()))
{
LogMessages.LOGGER.singletonClassAlreadyDeployed("provider", obj.getClass().getName());
}
else
{
LogMessages.LOGGER.addingProviderSingleton(obj.getClass().getName(), config.getClass());
providers.add(obj);
registered = true;
}
}
}
}
final Map properties = config.getProperties();
if (properties != null && !properties.isEmpty())
{
Feature appliationPropertiesRegistrationfeature = new Feature()
{
@Override
public boolean configure(FeatureContext featureContext)
{
for (Map.Entry property : properties.entrySet())
{
featureContext = featureContext.property(property.getKey(), property.getValue());
}
return true;
}
};
this.providers.add(0, appliationPropertiesRegistrationfeature);
}
return registered;
}
private void registerProvider(String clazz)
{
Class provider = null;
try
{
provider = Thread.currentThread().getContextClassLoader().loadClass(clazz.trim());
}
catch (ClassNotFoundException e)
{
throw new RuntimeException(e);
}
providerFactory.registerProvider(provider);
}
public boolean isUseContainerFormParams()
{
return useContainerFormParams;
}
public void setUseContainerFormParams(boolean useContainerFormParams)
{
this.useContainerFormParams = useContainerFormParams;
}
public List getJndiComponentResources()
{
return jndiComponentResources;
}
public void setJndiComponentResources(List jndiComponentResources)
{
this.jndiComponentResources = jndiComponentResources;
}
public String getApplicationClass()
{
return applicationClass;
}
public void setApplicationClass(String applicationClass)
{
this.applicationClass = applicationClass;
}
public String getInjectorFactoryClass()
{
return injectorFactoryClass;
}
public void setInjectorFactoryClass(String injectorFactoryClass)
{
this.injectorFactoryClass = injectorFactoryClass;
}
public boolean isDeploymentSensitiveFactoryEnabled()
{
return deploymentSensitiveFactoryEnabled;
}
public void setDeploymentSensitiveFactoryEnabled(boolean deploymentSensitiveFactoryEnabled)
{
this.deploymentSensitiveFactoryEnabled = deploymentSensitiveFactoryEnabled;
}
public boolean isAsyncJobServiceEnabled()
{
return asyncJobServiceEnabled;
}
public void setAsyncJobServiceEnabled(boolean asyncJobServiceEnabled)
{
this.asyncJobServiceEnabled = asyncJobServiceEnabled;
}
public int getAsyncJobServiceMaxJobResults()
{
return asyncJobServiceMaxJobResults;
}
public void setAsyncJobServiceMaxJobResults(int asyncJobServiceMaxJobResults)
{
this.asyncJobServiceMaxJobResults = asyncJobServiceMaxJobResults;
}
public long getAsyncJobServiceMaxWait()
{
return asyncJobServiceMaxWait;
}
public void setAsyncJobServiceMaxWait(long asyncJobServiceMaxWait)
{
this.asyncJobServiceMaxWait = asyncJobServiceMaxWait;
}
public int getAsyncJobServiceThreadPoolSize()
{
return asyncJobServiceThreadPoolSize;
}
public void setAsyncJobServiceThreadPoolSize(int asyncJobServiceThreadPoolSize)
{
this.asyncJobServiceThreadPoolSize = asyncJobServiceThreadPoolSize;
}
public String getAsyncJobServiceBasePath()
{
return asyncJobServiceBasePath;
}
public void setAsyncJobServiceBasePath(String asyncJobServiceBasePath)
{
this.asyncJobServiceBasePath = asyncJobServiceBasePath;
}
public Application getApplication()
{
return application;
}
public void setApplication(Application application)
{
this.application = application;
}
public boolean isRegisterBuiltin()
{
return registerBuiltin;
}
public void setRegisterBuiltin(boolean registerBuiltin)
{
this.registerBuiltin = registerBuiltin;
}
public List getProviderClasses()
{
return providerClasses;
}
public void setProviderClasses(List providerClasses)
{
this.providerClasses = providerClasses;
}
public List getProviders()
{
return providers;
}
public void setProviders(List providers)
{
this.providers = providers;
}
public List getActualProviderClasses()
{
return actualProviderClasses;
}
public void setActualProviderClasses(List actualProviderClasses)
{
this.actualProviderClasses = actualProviderClasses;
}
public List getActualResourceClasses()
{
return actualResourceClasses;
}
public void setActualResourceClasses(List actualResourceClasses)
{
this.actualResourceClasses = actualResourceClasses;
}
public boolean isSecurityEnabled()
{
return securityEnabled;
}
public void setSecurityEnabled(boolean securityEnabled)
{
this.securityEnabled = securityEnabled;
}
public List getJndiResources()
{
return jndiResources;
}
public void setJndiResources(List jndiResources)
{
this.jndiResources = jndiResources;
}
public List getResourceClasses()
{
return resourceClasses;
}
public void setResourceClasses(List resourceClasses)
{
this.resourceClasses = resourceClasses;
}
public Map getMediaTypeMappings()
{
return mediaTypeMappings;
}
public void setMediaTypeMappings(Map mediaTypeMappings)
{
this.mediaTypeMappings = mediaTypeMappings;
}
public List getResources()
{
return resources;
}
public void setResources(List resources)
{
this.resources = resources;
}
public Map getLanguageExtensions()
{
return languageExtensions;
}
public void setLanguageExtensions(Map languageExtensions)
{
this.languageExtensions = languageExtensions;
}
public Registry getRegistry()
{
return registry;
}
public void setRegistry(Registry registry)
{
this.registry = registry;
}
public Dispatcher getDispatcher()
{
return dispatcher;
}
public void setDispatcher(Dispatcher dispatcher)
{
this.dispatcher = dispatcher;
}
public ResteasyProviderFactory getProviderFactory()
{
return providerFactory;
}
public void setProviderFactory(ResteasyProviderFactory providerFactory)
{
this.providerFactory = providerFactory;
}
public void setMediaTypeParamMapping(String paramMapping)
{
this.paramMapping = paramMapping;
}
public List getResourceFactories()
{
return resourceFactories;
}
public void setResourceFactories(List resourceFactories)
{
this.resourceFactories = resourceFactories;
}
public List getUnwrappedExceptions()
{
return unwrappedExceptions;
}
public void setUnwrappedExceptions(List unwrappedExceptions)
{
this.unwrappedExceptions = unwrappedExceptions;
}
public Map getConstructedDefaultContextObjects()
{
return constructedDefaultContextObjects;
}
public void setConstructedDefaultContextObjects(Map constructedDefaultContextObjects)
{
this.constructedDefaultContextObjects = constructedDefaultContextObjects;
}
public Map getDefaultContextObjects()
{
return defaultContextObjects;
}
public void setDefaultContextObjects(Map defaultContextObjects)
{
this.defaultContextObjects = defaultContextObjects;
}
public List getScannedResourceClasses()
{
return scannedResourceClasses;
}
public void setScannedResourceClasses(List scannedResourceClasses)
{
this.scannedResourceClasses = scannedResourceClasses;
}
public List getScannedProviderClasses()
{
return scannedProviderClasses;
}
public void setScannedProviderClasses(List scannedProviderClasses)
{
this.scannedProviderClasses = scannedProviderClasses;
}
public List getScannedJndiComponentResources()
{
return scannedJndiComponentResources;
}
public void setScannedJndiComponentResources(List scannedJndiComponentResources)
{
this.scannedJndiComponentResources = scannedJndiComponentResources;
}
public boolean isWiderRequestMatching()
{
return widerRequestMatching;
}
public void setWiderRequestMatching(boolean widerRequestMatching)
{
this.widerRequestMatching = widerRequestMatching;
}
public boolean isAddCharset()
{
return addCharset;
}
public void setAddCharset(boolean addCharset)
{
this.addCharset = addCharset;
}
public InjectorFactory getInjectorFactory()
{
return injectorFactory;
}
public void setInjectorFactory(InjectorFactory injectorFactory)
{
this.injectorFactory = injectorFactory;
}
}
