application.java

Wicket一个开发Java Web应用程序框架。它使得开发web应用程序变得容易而轻松。 Wicket利用一个POJO data beans组件使得它可以与任何持久层技术相结合。

	}

	/**
	 * Iterate initializers list, calling any {@link org.apache.wicket.IDestroyer} instances found
	 * in it.
	 */
	private final void callDestroyers()
	{
		for (Iterator i = initializers.iterator(); i.hasNext();)
		{
			IInitializer initializer = (IInitializer)i.next();
			if (initializer instanceof IDestroyer)
			{
				log.info("[" + getName() + "] destroy: " + initializer);
				((IDestroyer)initializer).destroy(this);
			}
		}
	}

	/**
	 * Iterate initializers list, calling any instances found in it.
	 */
	private final void callInitializers()
	{
		for (Iterator i = initializers.iterator(); i.hasNext();)
		{
			IInitializer initializer = (IInitializer)i.next();
			log.info("[" + getName() + "] init: " + initializer);
			initializer.init(this);
		}
	}

	/**
	 * This method is still here for backwards compatibility with 1.1 source code. The
	 * getXXXSettings() methods are now preferred. This method will be removed post 1.2 version.
	 * 
	 * @return Application settings
	 * 
	 * @see Application#getApplicationSettings()
	 * @see Application#getDebugSettings()
	 * @see Application#getExceptionSettings()
	 * @see Application#getMarkupSettings()
	 * @see Application#getPageSettings()
	 * @see Application#getRequestCycleSettings()
	 * @see Application#getResourceSettings()
	 * @see Application#getSecuritySettings()
	 * @see Application#getSessionSettings()
	 */
	private Settings getSettings()
	{
		if (!settingsAccessible)
		{
			throw new WicketRuntimeException(
				"Use Application.init() method for configuring your application object");
		}

		if (settings == null)
		{
			settings = new Settings(this);
		}
		return settings;
	}

	/**
	 * @param properties
	 *            Properties map with names of any library initializers in it
	 */
	private final void load(final Properties properties)
	{
		addInitializer(properties.getProperty("initializer"));
		addInitializer(properties.getProperty(getName() + "-initializer"));
	}

	/**
	 * Called when wicket servlet is destroyed. Overrides do not have to call super.
	 * 
	 * @deprecated use {@link #onDestroy()} instead
	 */
	// TODO remove after deprecation release
	protected final void destroy()
	{
	}

	/**
	 * Called when wicket servlet is destroyed. Overrides do not have to call super.
	 */
	protected void onDestroy()
	{
	}

	/**
	 * @return Request cycle factory for this kind of session.
	 * @deprecated replaced by {@link #newRequestCycle(Request, Response)}
	 */
	// TODO remove after deprecation release
	protected final Object getRequestCycleFactory()
	{
		throw new UnsupportedOperationException();
	}

	/**
	 * Gets the factory for creating session instances.
	 * 
	 * @return Factory for creating session instances
	 * @deprecated replaced by {@link #newSession(Request, Response)}
	 */
	// TODO remove after deprecation release
	protected final Object getSessionFactory()
	{
		throw new UnsupportedOperationException();
	}

	/**
	 * Allows for initialization of the application by a subclass. <strong>Use this method for any
	 * application setup instead of the constructor.</strong>
	 */
	protected void init()
	{
	}

	/**
	 * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL IT.
	 */
	protected void internalDestroy()
	{
		// Clear caches of Class keys so the classloader can be garbage
		// collected (WICKET-625)
		PropertyResolver.destroy(this);
		getMarkupSettings().getMarkupCache().shutdown();

		onDestroy();
		callDestroyers();
		applicationKeyToApplication.remove(getApplicationKey());
		Session.unset();
		RequestContext.unset();
		RequestCycle.set(null);
	}

	/**
	 * THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT OVERRIDE OR CALL.
	 * 
	 * Internal initialization.
	 */
	protected void internalInit()
	{
		settingsAccessible = true;
		IPageSettings pageSettings = getPageSettings();

		// Install default component resolvers
		pageSettings.addComponentResolver(new ParentResolver());
		pageSettings.addComponentResolver(new AutoComponentResolver());
		pageSettings.addComponentResolver(new MarkupInheritanceResolver());
		pageSettings.addComponentResolver(new HtmlHeaderResolver());
		pageSettings.addComponentResolver(new WicketLinkResolver());
		pageSettings.addComponentResolver(new WicketMessageResolver());
		pageSettings.addComponentResolver(new WicketMessageTagHandler());
		pageSettings.addComponentResolver(new FragmentResolver());
		pageSettings.addComponentResolver(new RelativePathPrefixHandler());
		pageSettings.addComponentResolver(new EnclosureResolver());
		pageSettings.addComponentResolver(new WicketContainerResolver());
		pageSettings.addComponentResolver(new BorderBodyResolver());

		// Install button image resource factory
		getResourceSettings().addResourceFactory("buttonFactory",
			new DefaultButtonImageResourceFactory());

		String applicationKey = getApplicationKey();
		applicationKeyToApplication.put(applicationKey, this);

		sessionStore = newSessionStore();
		converterLocator = newConverterLocator();
	}

	/**
	 * Creates and returns a new instance of {@link IConverterLocator}.
	 * 
	 * @return A new {@link IConverterLocator} instance
	 */
	protected IConverterLocator newConverterLocator()
	{
		return new ConverterLocator();
	}

	/**
	 * creates a new request logger when requests logging is enabled.
	 * 
	 * @return The new request logger
	 * 
	 */
	protected IRequestLogger newRequestLogger()
	{
		return new RequestLogger();
	}

	/**
	 * Creates a new session facade. Is called once per application, and is typically not something
	 * clients reimplement.
	 * 
	 * @return The session facade
	 */
	protected abstract ISessionStore newSessionStore();

	/**
	 * Notifies the registered component instantiation listeners of the construction of the provided
	 * component
	 * 
	 * @param component
	 *            the component that is being instantiated
	 */
	final void notifyComponentInstantiationListeners(final Component component)
	{
		final int len = componentInstantiationListeners.length;
		for (int i = 0; i < len; i++)
		{
			componentInstantiationListeners[i].onInstantiation(component);
		}
	}

	private List componentOnBeforeRenderListeners = null;

	/**
	 * Adds an {@link IComponentOnBeforeRenderListener}. This method should typically only be
	 * called during application startup; it is not thread safe.
	 * 
	 * @param listener
	 */
	final public void addComponentOnBeforeRenderListener(IComponentOnBeforeRenderListener listener)
	{
		if (componentOnBeforeRenderListeners == null)
		{
			componentOnBeforeRenderListeners = new ArrayList();
		}

		if (componentOnBeforeRenderListeners.contains(listener) == false)
		{
			componentOnBeforeRenderListeners.add(listener);
		}
	}

	/**
	 * Removes an {@link IComponentOnBeforeRenderListener}.
	 * 
	 * @param listener
	 */
	final public void removeComponentOnBeforeRenderListener(
		IComponentOnBeforeRenderListener listener)
	{
		if (componentOnBeforeRenderListeners != null)
		{
			componentOnBeforeRenderListeners.remove(listener);
			if (componentOnBeforeRenderListeners.isEmpty())
			{
				componentOnBeforeRenderListeners = null;
			}
		}
	}

	/**
	 * Notifies the {@link IComponentOnBeforeRenderListener}s.
	 * 
	 * @param component
	 */
	final void notifyComponentOnBeforeRenderListeners(Component component)
	{
		if (componentOnBeforeRenderListeners != null)
		{
			for (Iterator i = componentOnBeforeRenderListeners.iterator(); i.hasNext();)
			{
				IComponentOnBeforeRenderListener listener = (IComponentOnBeforeRenderListener)i.next();
				listener.onBeforeRender(component);
			}
		}
	}

	private List componentOnAfterRenderListeners = null;

	/**
	 * Adds an {@link IComponentOnAfterRenderListener}. This method should typically only be called
	 * during application startup; it is not thread safe.
	 * 
	 * @param listener
	 */
	final public void addComponentOnAfterRenderListener(IComponentOnAfterRenderListener listener)
	{
		if (componentOnAfterRenderListeners == null)
		{
			componentOnAfterRenderListeners = new ArrayList();
		}

		if (componentOnAfterRenderListeners.contains(listener) == false)
		{
			componentOnAfterRenderListeners.add(listener);
		}
	}

	/**
	 * Removes an {@link IComponentOnAfterRenderListener}.
	 * 
	 * @param listener
	 */
	final public void removeComponentOnAfterRenderListener(IComponentOnAfterRenderListener listener)
	{
		if (componentOnAfterRenderListeners != null)
		{
			componentOnAfterRenderListeners.remove(listener);
			if (componentOnAfterRenderListeners.isEmpty())
			{
				componentOnAfterRenderListeners = null;
			}
		}
	}

	/**
	 * Notifies the {@link IComponentOnAfterRenderListener}s.
	 * 
	 * @param component
	 */
	final void notifyComponentOnAfterRenderListeners(Component component)
	{
		if (componentOnAfterRenderListeners != null)
		{
			for (Iterator i = componentOnAfterRenderListeners.iterator(); i.hasNext();)
			{
				IComponentOnAfterRenderListener listener = (IComponentOnAfterRenderListener)i.next();
				listener.onAfterRender(component);
			}
		}
	}

	private List renderHeadListeners = null;

	/**
	 * Adds a listener that will be invoked for every header response
	 * 
	 * @param listener
	 */
	public final void addRenderHeadListener(IHeaderContributor listener)
	{
		if (renderHeadListeners == null)
		{
			renderHeadListeners = new ArrayList();
		}
		renderHeadListeners.add(listener);
	}

	/**
	 * 
	 * @param listener
	 */
	public void removeRenderHeadListener(IHeaderContributor listener)
	{
		if (renderHeadListeners != null)
		{
			renderHeadListeners.remove(listener);
			if (renderHeadListeners.isEmpty())
			{
				renderHeadListeners = null;
			}
		}
	}

	/**
	 * INTERNAL
	 * 
	 * @param response
	 */
	public void notifyRenderHeadListener(IHeaderResponse response)
	{
		if (renderHeadListeners != null)
		{
			for (Iterator i = renderHeadListeners.iterator(); i.hasNext();)
			{
				IHeaderContributor listener = (IHeaderContributor)i.next();
				listener.renderHead(response);
			}
		}
	}
}