public static void apply(final ServletContext context) {
// Maybe configurable?
context.removeAttribute("javax.faces.FACELETS_REFRESH_PERIOD");
context.setAttribute("javax.faces.FACELETS_REFRESH_PERIOD", "1");
context.removeAttribute("facelets.REFRESH_PERIOD");
context.setAttribute("facelets.REFRESH_PERIOD", "1");
context.removeAttribute("javax.faces.PROJECT_STAGE");
context.setAttribute("javax.faces.PROJECT_STAGE", "Development");
context.setInitParameter("javax.faces.FACELETS_REFRESH_PERIOD", "1");
context.setInitParameter("javax.faces.PROJECT_STAGE", "Development");
context.setInitParameter("facelets.REFRESH_PERIOD", "1");
if (LOGGER.isLevelEnabled(Level.TRACE)) {
Enumeration<String> names = context.getAttributeNames();
if (names != null) {
while (names.hasMoreElements()) {
String k = names.nextElement();
LOGGER.trace("CONTEXT ATTRIBUTE {} value: {}", k, context.getAttribute(k));
}
}
names = context.getInitParameterNames();
if (names != null) {
while (names.hasMoreElements()) {
String k = names.nextElement();
LOGGER.trace("CONTEXT INIT PARAM {} value: {}", k, context.getInitParameter(k));
}
}
}
}
@Override
public void contextDestroyed(ServletContextEvent sce) {
cdiContainer.stop();
ServletContext context = sce.getServletContext();
context.removeAttribute("org.ops4j.pax.cdi.ClassIntrospecter");
context.removeAttribute("org.ops4j.pax.cdi.BeanManager");
super.contextDestroyed(sce);
}
/**
* Sets the preferred locale for the specified servlet context. It is the default locale for the
* whole Web application.
*
* <p>Default: null (no preferred locale -- depending on browser's setting).
*
* @param locale the preferred Locale. If null, it means no preferred locale
* @see #getPreferredLocale(HttpSession,ServletRequest)
* @since 3.6.3
*/
public static final void setPreferredLocale(ServletContext ctx, Locale locale) {
if (locale != null) {
ctx.setAttribute(Attributes.PREFERRED_LOCALE, locale);
} else {
ctx.removeAttribute(Attributes.PREFERRED_LOCALE);
ctx.removeAttribute(PX_PREFERRED_LOCALE);
}
}
public static void shutdown() {
_servletContext.removeAttribute(ServletContextKeyEnum.THREADPOOL_EXECUTOR_CONTAINER);
_servletContext.removeAttribute(ServletContextKeyEnum.LOGIC_THREADPOOL_NAME);
ScheduledExecutorService cleanSessionTimer =
(ScheduledExecutorService)
_servletContext.getAttribute(ServletContextKeyEnum.USER_DEFINED_SESSION_CLEAN_TIMER);
if (cleanSessionTimer != null) {
cleanSessionTimer.shutdown();
}
_servletContext.removeAttribute(ServletContextKeyEnum.USER_DEFINED_SESSION_CLEAN_TIMER);
_threadPoolContainer.shutdownNow();
}
private void doRemoveAttribute(String name, int scope) {
switch (scope) {
case PAGE_SCOPE:
attributes.remove(name);
break;
case REQUEST_SCOPE:
request.removeAttribute(name);
break;
case SESSION_SCOPE:
if (session == null) {
throw new IllegalStateException(Localizer.getMessage("jsp.error.page.noSession"));
}
session.removeAttribute(name);
break;
case APPLICATION_SCOPE:
context.removeAttribute(name);
break;
default:
throw new IllegalArgumentException("Invalid scope");
}
}
@Test
public void getSetAttributes() {
ServletContext context = new ServletContext1(new MockWebContext());
// name0 = value0
context.setAttribute("name0", "value0");
Enumeration<String> attributeNames = context.getAttributeNames();
assertTrue(attributeNames.hasMoreElements());
assertEquals("name0", attributeNames.nextElement());
assertFalse(attributeNames.hasMoreElements());
assertEquals("value0", context.getAttribute("name0"));
assertNull(context.getAttribute("name1"));
// name0 = value0, name1 = value1
context.setAttribute("name1", "value1");
attributeNames = context.getAttributeNames();
assertTrue(attributeNames.hasMoreElements());
String name = attributeNames.nextElement();
assertTrue(name.equals("name0") || name.equals("name1"));
assertTrue(attributeNames.hasMoreElements());
name = attributeNames.nextElement();
assertTrue(name.equals("name0") || name.equals("name1"));
assertFalse(attributeNames.hasMoreElements());
assertEquals("value0", context.getAttribute("name0"));
assertEquals("value1", context.getAttribute("name1"));
// name0 = edited, name1 = value1
context.setAttribute("name0", "edited");
attributeNames = context.getAttributeNames();
assertTrue(attributeNames.hasMoreElements());
name = attributeNames.nextElement();
assertTrue(name.equals("name0") || name.equals("name1"));
assertTrue(attributeNames.hasMoreElements());
name = attributeNames.nextElement();
assertTrue(name.equals("name0") || name.equals("name1"));
assertFalse(attributeNames.hasMoreElements());
assertEquals("edited", context.getAttribute("name0"));
assertEquals("value1", context.getAttribute("name1"));
// name0 = edited
context.removeAttribute("name1");
attributeNames = context.getAttributeNames();
assertTrue(attributeNames.hasMoreElements());
assertEquals("name0", attributeNames.nextElement());
assertFalse(attributeNames.hasMoreElements());
assertEquals("edited", context.getAttribute("name0"));
assertNull(context.getAttribute("name1"));
// empty
context.setAttribute("name0", null);
attributeNames = context.getAttributeNames();
assertFalse(attributeNames.hasMoreElements());
assertNull(context.getAttribute("name0"));
assertNull(context.getAttribute("name1"));
}
@Override
public void contextDestroyed(ServletContextEvent event) {
ServletContext servletContext = event.getServletContext();
if (servletContext.getAttribute(CONTROL_ATTRIBUTE_NAME) != null) {
servletContext.removeAttribute(CONTROL_ATTRIBUTE_NAME);
}
}
/**
* Gracefully shut down this database, releasing any resources that were allocated at
* initialization.
*
* @param event ServletContextEvent to process
*/
public void contextDestroyed(ServletContextEvent event) {
log.info("Finalizing memory database plug in");
if (database != null) {
try {
database.close();
} catch (Exception e) {
log.error("Closing memory database", e);
}
}
context.removeAttribute(DATABASE_KEY);
context.removeAttribute(PROTOCOLS_KEY);
database = null;
context = null;
}
/**
* Clearing the in-memory configuration parameters, we will receive notification that the servlet
* context is about to be shut down
*/
@Override
public void contextDestroyed(ServletContextEvent sce) {
synchronized (servletContext) {
logger.info("Webapp shutdown");
// XXX Paul: grabbed this from
// http://opensource.atlassian.com/confluence/spring/display/DISC/Memory+leak+-+classloader+won%27t+let+go
// in hopes that we can clear all the issues with J2EE containers
// during shutdown
try {
ServletContext ctx = sce.getServletContext();
// prepare spring for shutdown
Introspector.flushCaches();
// dereg any drivers
for (Enumeration e = DriverManager.getDrivers(); e.hasMoreElements(); ) {
Driver driver = (Driver) e.nextElement();
if (driver.getClass().getClassLoader() == getClass().getClassLoader()) {
DriverManager.deregisterDriver(driver);
}
}
// shutdown jmx
JMXAgent.shutdown();
// shutdown the persistence thread
FilePersistenceThread persistenceThread = FilePersistenceThread.getInstance();
if (persistenceThread != null) {
persistenceThread.shutdown();
}
// shutdown spring
Object attr =
ctx.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
if (attr != null) {
// get web application context from the servlet context
ConfigurableWebApplicationContext applicationContext =
(ConfigurableWebApplicationContext) attr;
ConfigurableBeanFactory factory = applicationContext.getBeanFactory();
// for (String scope : factory.getRegisteredScopeNames()) {
// logger.debug("Registered scope: " + scope);
// }
try {
for (String singleton : factory.getSingletonNames()) {
logger.debug("Registered singleton: " + singleton);
factory.destroyScopedBean(singleton);
}
} catch (RuntimeException e) {
}
factory.destroySingletons();
ctx.removeAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
applicationContext.close();
}
getContextLoader().closeWebApplicationContext(ctx);
// org.apache.commons.logging.LogFactory.releaseAll();
// org.apache.log4j.LogManager.getLoggerRepository().shutdown();
// org.apache.log4j.LogManager.shutdown();
} catch (Throwable e) {
e.printStackTrace();
}
}
}
public static void clearInstance(ServletContext sc) {
ApplicationAssociate me = (ApplicationAssociate) sc.getAttribute(ASSOCIATE_KEY);
if (null != me) {
if (null != me.resourceBundles) {
me.resourceBundles.clear();
}
}
sc.removeAttribute(ASSOCIATE_KEY);
}
/** Removes bean from scope. */
public Object remove(String name) {
Object result = null;
ServletContext sc = getServletContext();
result = sc.getAttribute(name);
sc.removeAttribute(name);
return result;
}
private void initConfigMonitoring(ServletContext context) {
//noinspection unchecked
Collection<URI> webURIs = (Collection<URI>) context.getAttribute("com.sun.faces.webresources");
if (isDevModeEnabled() && webURIs != null && !webURIs.isEmpty()) {
webResourcePool =
new ScheduledThreadPoolExecutor(1, new MojarraThreadFactory("WebResourceMonitor"));
webResourcePool.scheduleAtFixedRate(
new WebConfigResourceMonitor(context, webURIs), 2000, 2000, TimeUnit.MILLISECONDS);
}
context.removeAttribute("com.sun.faces.webresources");
}
protected void unregisterClpMessageListeners(ServletContext servletContext) throws Exception {
List<MessageListener> clpMessageListeners =
(List<MessageListener>) servletContext.getAttribute(WebKeys.CLP_MESSAGE_LISTENERS);
if (clpMessageListeners != null) {
servletContext.removeAttribute(WebKeys.CLP_MESSAGE_LISTENERS);
for (MessageListener clpMessageListener : clpMessageListeners) {
MessageBusUtil.unregisterMessageListener(DestinationNames.HOT_DEPLOY, clpMessageListener);
}
}
}
static void destroySession(HttpSession session) {
ServletContext context = session.getServletContext();
String user = (String) session.getAttribute(ATTRIBUTE_SESSIONUSER);
if (user != null) {
String current = (String) session.getAttribute(ATTRIBUTE_SESSIONMATCH);
String match = (String) context.getAttribute(ATTRIBUTE_SESSIONMATCH + "." + user);
if (current != null && current.equals(match)) {
context.removeAttribute(ATTRIBUTE_SESSIONMATCH + "." + user);
}
}
session.removeAttribute(ATTRIBUTE_SESSIONUSER);
session.removeAttribute(ATTRIBUTE_SESSIONMATCH);
}
/**
* This method bootstraps JSF based on the parsed configuration resources.
*
* @param sc the <code>ServletContext</code> for the application that requires initialization
*/
public void initialize(ServletContext sc) {
if (!hasBeenInitialized(sc)) {
initializedContexts.add(sc);
try {
WebConfiguration webConfig = WebConfiguration.getInstance(sc);
boolean validating = webConfig.isOptionEnabled(ValidateFacesConfigFiles);
ExecutorService executor = createExecutorService();
Document[] facesDocuments =
getConfigDocuments(sc, getFacesConfigResourceProviders(), executor, validating);
WebInfFacesConfigInfo facesConfigInfo =
new WebInfFacesConfigInfo(facesDocuments[facesDocuments.length - 1]);
facesDocuments = sortDocuments(facesDocuments, facesConfigInfo);
boolean isFaceletsDisabled = isFaceletsDisabled(webConfig, facesConfigInfo);
if (!facesConfigInfo.isMetadataComplete()) {
// execute the Task responsible for finding annotation classes
Future<Map<Class<? extends Annotation>, Set<Class<?>>>> annotationScan =
executor.submit(new AnnotationScanTask(sc));
pushTaskToContext(sc, annotationScan);
}
// process the ordered documents
FACES_CONFIG_PROCESSOR_CHAIN.process(facesDocuments);
if (!isFaceletsDisabled) {
FACELET_TAGLIB_CONFIG_PROCESSOR_CHAIN.process(
getConfigDocuments(sc, getFaceletConfigResourceProviders(), executor, validating));
}
executor.shutdown();
publishPostConfigEvent();
} catch (Exception e) {
// clear out any configured factories
releaseFactories();
if (LOGGER.isLoggable(Level.INFO)) {
LOGGER.log(Level.INFO, "Unsanitized stacktrace from failed start...", e);
}
Throwable t = unwind(e);
throw new ConfigurationException("CONFIGURATION FAILED! " + t.getMessage(), t);
} finally {
sc.removeAttribute(ANNOTATIONS_SCAN_TASK_KEY);
}
}
}
@Override
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
ServletContext context = request.getServletContext();
String attrName = request.getParameter("attrName");
String attrValue = request.getParameter("attrValue");
String command = request.getParameter("command");
switch (command) {
case "set":
context.setAttribute(attrName, attrValue);
break;
default:
context.removeAttribute(attrName);
}
response.setContentType("text/plain;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("ServletContext에 값을 저장하거나 변경, 삭제하였습니다.");
}
public void clear() {
Iterator keys = keySet().iterator();
while (keys.hasNext()) {
context.removeAttribute((String) keys.next());
}
}
public Object remove(Object key) {
String skey = key(key);
Object previous = context.getAttribute(skey);
context.removeAttribute(skey);
return (previous);
}
/**
* Destroys the {@link Config} for the given servlet context.
*
* @param servletContext the web apps servlet context
*/
public void destroyConfig(ServletContext servletContext) {
servletContext.log("Cleaning up Stormpath config.");
servletContext.removeAttribute(CONFIG_ATTRIBUTE_NAME);
}
public void destroy() {
log.info("开始停止应用");
application.removeAttribute("ctx");
super.destroy();
}
@Override
public void removeAttribute(String s) {
proxy.removeAttribute(s);
}
@Override
public void contextDestroyed(ServletContextEvent event) {
context.removeAttribute("auditLog");
System.out.println("application stopping...");
}
/**
* This method bootstraps JSF based on the parsed configuration resources.
*
* @param sc the <code>ServletContext</code> for the application that requires initialization
*/
public void initialize(ServletContext sc) {
if (!hasBeenInitialized(sc)) {
initializedContexts.add(sc);
ExecutorService executor = null;
try {
WebConfiguration webConfig = WebConfiguration.getInstance(sc);
boolean validating = webConfig.isOptionEnabled(ValidateFacesConfigFiles);
if (useThreads(sc)) {
executor = createExecutorService();
}
DocumentInfo[] facesDocuments =
getConfigDocuments(sc, getFacesConfigResourceProviders(), executor, validating);
FacesConfigInfo webInfFacesConfigInfo =
new FacesConfigInfo(facesDocuments[facesDocuments.length - 1]);
facesDocuments = sortDocuments(facesDocuments, webInfFacesConfigInfo);
InitFacesContext context = (InitFacesContext) FacesContext.getCurrentInstance();
InjectionProvider containerConnector =
InjectionProviderFactory.createInstance(context.getExternalContext());
context.getAttributes().put(INJECTION_PROVIDER_KEY, containerConnector);
boolean isFaceletsDisabled = isFaceletsDisabled(webConfig, webInfFacesConfigInfo);
if (!webInfFacesConfigInfo.isWebInfFacesConfig()
|| !webInfFacesConfigInfo.isMetadataComplete()) {
// execute the Task responsible for finding annotation classes
ProvideMetadataToAnnotationScanTask taskMetadata =
new ProvideMetadataToAnnotationScanTask(facesDocuments, containerConnector);
Future<Map<Class<? extends Annotation>, Set<Class<?>>>> annotationScan;
if (executor != null) {
annotationScan = executor.submit(new AnnotationScanTask(sc, context, taskMetadata));
pushTaskToContext(sc, annotationScan);
} else {
annotationScan =
new FutureTask<Map<Class<? extends Annotation>, Set<Class<?>>>>(
new AnnotationScanTask(sc, context, taskMetadata));
((FutureTask) annotationScan).run();
}
pushTaskToContext(sc, annotationScan);
}
// see if the app is running in a HA enabled env
if (containerConnector instanceof HighAvailabilityEnabler) {
((HighAvailabilityEnabler) containerConnector).enableHighAvailability(sc);
}
// process the ordered documents
FACES_CONFIG_PROCESSOR_CHAIN.process(sc, facesDocuments);
if (!isFaceletsDisabled) {
FACELET_TAGLIB_CONFIG_PROCESSOR_CHAIN.process(
sc,
getConfigDocuments(sc, getFaceletConfigResourceProviders(), executor, validating));
}
publishPostConfigEvent();
} catch (Exception e) {
// clear out any configured factories
releaseFactories();
Throwable t = e;
if (!(e instanceof ConfigurationException)) {
t = new ConfigurationException("CONFIGURATION FAILED! " + t.getMessage(), t);
}
throw (ConfigurationException) t;
} finally {
if (executor != null) {
executor.shutdown();
}
sc.removeAttribute(ANNOTATIONS_SCAN_TASK_KEY);
}
}
}
public String removeApplicationBean2() {
ServletContext request =
(ServletContext) FacesContext.getCurrentInstance().getExternalContext().getContext();
request.removeAttribute("applicationBean");
return null;
}
public String clearStatusMessage() {
if (null != servletContext) {
servletContext.removeAttribute("previousRequestStatus");
}
return null;
}
public void contextDestroyed(ServletContextEvent event) {
ServletContext servletContext = event.getServletContext();
servletContext.removeAttribute(SHARED_CONTEXT_KEY);
}
public void contextInitialized(ServletContextEvent sce) {
ServletContext context = sce.getServletContext();
Timer timer = Timer.getInstance();
if (timer != null) {
timer.startTiming();
}
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(
Level.FINE,
MessageFormat.format(
"ConfigureListener.contextInitialized({0})", getServletContextIdentifier(context)));
}
webConfig = WebConfiguration.getInstance(context);
ConfigManager configManager = ConfigManager.getInstance();
if (configManager.hasBeenInitialized(context)) {
return;
}
// Check to see if the FacesServlet is present in the
// web.xml. If it is, perform faces configuration as normal,
// otherwise, simply return.
Object mappingsAdded = context.getAttribute(RIConstants.FACES_INITIALIZER_MAPPINGS_ADDED);
if (mappingsAdded != null) {
context.removeAttribute(RIConstants.FACES_INITIALIZER_MAPPINGS_ADDED);
}
WebXmlProcessor webXmlProcessor = new WebXmlProcessor(context);
if (mappingsAdded == null) {
if (!webXmlProcessor.isFacesServletPresent()) {
if (!webConfig.isOptionEnabled(ForceLoadFacesConfigFiles)) {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(
Level.FINE,
"No FacesServlet found in deployment descriptor - bypassing configuration");
}
WebConfiguration.clear(context);
return;
}
} else {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(
Level.FINE,
"FacesServlet found in deployment descriptor - processing configuration.");
}
}
}
// bootstrap of faces required
webAppListener = new WebappLifecycleListener(context);
webAppListener.contextInitialized(sce);
InitFacesContext initContext = new InitFacesContext(context);
ReflectionUtils.initCache(Thread.currentThread().getContextClassLoader());
Throwable caughtThrowable = null;
try {
if (LOGGER.isLoggable(Level.INFO)) {
LOGGER.log(Level.INFO, "jsf.config.listener.version", getServletContextIdentifier(context));
}
// see if we need to disable our TLValidator
Util.setHtmlTLVActive(webConfig.isOptionEnabled(EnableHtmlTagLibraryValidator));
if (webConfig.isOptionEnabled(VerifyFacesConfigObjects)) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.warning("jsf.config.verifyobjects.development_only");
}
// if we're verifying, force bean validation to occur at startup as well
webConfig.overrideContextInitParameter(EnableLazyBeanValidation, false);
Verifier.setCurrentInstance(new Verifier());
}
initScripting();
configManager.initialize(context);
if (shouldInitConfigMonitoring()) {
initConfigMonitoring(context);
}
// Step 7, verify that all the configured factories are available
// and optionall that configured objects can be created.
Verifier v = Verifier.getCurrentInstance();
if (v != null && !v.isApplicationValid()) {
if (LOGGER.isLoggable(Level.SEVERE)) {
LOGGER.severe("jsf.config.verifyobjects.failures_detected");
StringBuilder sb = new StringBuilder(128);
for (String m : v.getMessages()) {
sb.append(m).append('\n');
}
LOGGER.severe(sb.toString());
}
}
registerELResolverAndListenerWithJsp(context, false);
ELContext elctx = new ELContextImpl(initContext.getApplication().getELResolver());
elctx.putContext(FacesContext.class, initContext);
initContext.setELContext(elctx);
ApplicationAssociate associate = ApplicationAssociate.getInstance(context);
if (associate != null) {
associate.setContextName(getServletContextIdentifier(context));
BeanManager manager = associate.getBeanManager();
List<String> eagerBeans = manager.getEagerBeanNames();
if (!eagerBeans.isEmpty()) {
for (String name : eagerBeans) {
manager.create(name, initContext);
}
}
boolean isErrorPagePresent = webXmlProcessor.isErrorPagePresent();
associate.setErrorPagePresent(isErrorPagePresent);
context.setAttribute(RIConstants.ERROR_PAGE_PRESENT_KEY_NAME, isErrorPagePresent);
}
Application app = initContext.getApplication();
app.subscribeToEvent(PostConstructViewMapEvent.class, UIViewRoot.class, webAppListener);
app.subscribeToEvent(PreDestroyViewMapEvent.class, UIViewRoot.class, webAppListener);
webConfig.doPostBringupActions();
} catch (Throwable t) {
if (LOGGER.isLoggable(Level.SEVERE)) {
LOGGER.log(Level.SEVERE, "Critical error during deployment: ", t);
}
caughtThrowable = t;
} finally {
Verifier.setCurrentInstance(null);
initContext.release();
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE, "jsf.config.listener.version.complete");
}
if (timer != null) {
timer.stopTiming();
timer.logResult("Initialization of context " + getServletContextIdentifier(context));
}
if (null != caughtThrowable) {
throw new RuntimeException(caughtThrowable);
}
}
}
@Override
public void contextDestroyed(ServletContextEvent sce) {
ServletContext servletContext = sce.getServletContext();
servletContext.removeAttribute(BOOK_STORAGE_NAME);
}
/**
* This method will be invoked {@link WebConfigResourceMonitor} when changes to any of the
* faces-config.xml files included in WEB-INF are modified.
*/
private void reload(ServletContext sc) {
if (LOGGER.isLoggable(Level.INFO)) {
LOGGER.log(
Level.INFO,
"Reloading JSF configuration for context {0}",
getServletContextIdentifier(sc));
}
GroovyHelper helper = GroovyHelper.getCurrentInstance();
if (helper != null) {
helper.setClassLoader();
}
// tear down the application
try {
// this will only be true in the automated test usage scenario
if (null != webAppListener) {
List<HttpSession> sessions = webAppListener.getActiveSessions();
if (sessions != null) {
for (HttpSession session : sessions) {
if (LOGGER.isLoggable(Level.INFO)) {
LOGGER.log(Level.INFO, "Invalidating Session {0}", session.getId());
}
session.invalidate();
}
}
}
ApplicationAssociate associate = ApplicationAssociate.getInstance(sc);
if (associate != null) {
BeanManager manager = associate.getBeanManager();
for (Map.Entry<String, BeanBuilder> entry : manager.getRegisteredBeans().entrySet()) {
String name = entry.getKey();
BeanBuilder bean = entry.getValue();
if (ELUtils.Scope.APPLICATION.toString().equals(bean.getScope())) {
if (LOGGER.isLoggable(Level.INFO)) {
LOGGER.log(Level.INFO, "Removing application scoped managed bean: {0}", name);
}
sc.removeAttribute(name);
}
}
}
// Release any allocated application resources
FactoryFinder.releaseFactories();
} catch (Exception e) {
e.printStackTrace();
} finally {
FacesContext initContext = new InitFacesContext(sc);
ApplicationAssociate.clearInstance(initContext.getExternalContext());
ApplicationAssociate.setCurrentInstance(null);
// Release the initialization mark on this web application
ConfigManager.getInstance().destory(sc);
initContext.release();
ReflectionUtils.clearCache(Thread.currentThread().getContextClassLoader());
WebConfiguration.clear(sc);
}
// bring the application back up, avoid re-registration of certain JSP
// artifacts. No verification will be performed either to make this
// light weight.
// init a new WebAppLifecycleListener so that the cached ApplicationAssociate
// is removed.
webAppListener = new WebappLifecycleListener(sc);
FacesContext initContext = new InitFacesContext(sc);
ReflectionUtils.initCache(Thread.currentThread().getContextClassLoader());
try {
ConfigManager configManager = ConfigManager.getInstance();
configManager.initialize(sc);
registerELResolverAndListenerWithJsp(sc, true);
ApplicationAssociate associate = ApplicationAssociate.getInstance(sc);
if (associate != null) {
Boolean errorPagePresent =
(Boolean) sc.getAttribute(RIConstants.ERROR_PAGE_PRESENT_KEY_NAME);
if (null != errorPagePresent) {
associate.setErrorPagePresent(errorPagePresent);
associate.setContextName(getServletContextIdentifier(sc));
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
initContext.release();
}
if (LOGGER.isLoggable(Level.INFO)) {
LOGGER.log(Level.INFO, "Reload complete.", getServletContextIdentifier(sc));
}
}
static void clear(ServletContext servletContext) {
servletContext.removeAttribute(WEB_CONFIG_KEY);
}
