getBundle. Now you can get your object by calling
* getObject or getString on that bundle.
*
* When a bundle is demanded for a specific locale, the ResourceBundle
* is searched in following order (def. language stands for the
* two letter ISO language code of the default locale (see
* Locale.getDefault()).
*
baseName_language code_country code_variant baseName_language code_country code baseName_language code baseName_def. language_def. country_def. variant baseName_def. language_def. country baseName_def. language baseName* *
A bundle is backed up by less specific bundles (omitting variant, country * or language). But it is not backed up by the default language locale. * *
If you provide a bundle for a given locale, say
* Bundle_en_UK_POSIX, you must also provide a bundle for
* all sub locales, ie. Bundle_en_UK, Bundle_en, and
* Bundle.
*
*
When a bundle is searched, we look first for a class with the given
* name, then for a file with .properties extension in the
* classpath. The name must be a fully qualified classname (with dots as
* path separators).
*
*
(Note: This implementation always backs up the class with a properties
* file if that is existing, but you shouldn't rely on this, if you want to
* be compatible to the standard JDK.)
*
* @author Jochen Hoenicke
* @author Eric Blake (ebb9@email.byu.edu)
* @see Locale
* @see ListResourceBundle
* @see PropertyResourceBundle
* @since 1.1
* @status updated to 1.4
*/
public abstract class ResourceBundle
{
/**
* Maximum size of our cache of ResourceBundles keyed by
* {@link BundleKey} instances.
*
* @see BundleKey
*/
private static final int CACHE_SIZE = 100;
/**
* The parent bundle. This is consulted when you call getObject and there
* is no such resource in the current bundle. This field may be null.
*/
protected ResourceBundle parent;
/**
* The locale of this resource bundle. You can read this with
* getLocale and it is automatically set in
* getBundle.
*/
private Locale locale;
/**
* A VM-wide cache of resource bundles already fetched.
*
* This {@link Map} is a Least Recently Used (LRU) cache, of the last
* {@link #CACHE_SIZE} accessed A sequence of candidate bundle names are generated, and tested in
* this order, where the suffix 1 means the string from the specified
* locale, and the suffix 2 means the string from the default locale: In the sequence, entries with an empty string are ignored. Next,
* Next, the parent chain is implemented. The remaining candidate names
* in the above sequence are tested in a similar manner, and if any results
* in a resource bundle, it is assigned as the parent of the first bundle
* using the For example, suppose the following class and property files are
* provided: MyResources.class, MyResources_fr_CH.properties,
* MyResources_fr_CH.class, MyResources_fr.properties,
* MyResources_en.properties, and MyResources_es_ES.class. The contents of
* all files are valid (that is, public non-abstract subclasses of
* ResourceBundle with public nullary constructors for the ".class" files,
* syntactically correct ".properties" files). The default locale is
* Locale("en", "UK"). Calling getBundle with the shown locale argument values instantiates
* resource bundles from the following sources: The file MyResources_fr_CH.properties is never used because it is hidden
* by MyResources_fr_CH.class.ResourceBundles keyed by the
* tuple: default locale, resource-bundle name, resource-bundle locale, and
* classloader.
*
* @see BundleKey
*/
private static MaphandleGetObject for this resource and all of its parents,
* until it finds a non-null resource.
*
* @param key the name of the resource
* @throws MissingResourceException if the resource can't be found
* @throws NullPointerException if key is null
*/
public final Object getObject(String key)
{
for (ResourceBundle bundle = this; bundle != null; bundle = bundle.parent)
{
Object o = bundle.handleGetObject(key);
if (o != null)
return o;
}
String className = getClass().getName();
throw new MissingResourceException("Key '" + key
+ "'not found in Bundle: "
+ className, className, key);
}
/**
* Return the actual locale of this bundle. You can use it after calling
* getBundle, to know if the bundle for the desired locale was loaded or
* if the fall back was used.
*
* @return the bundle's locale
*/
public Locale getLocale()
{
return locale;
}
/**
* Set the parent of this bundle. The parent is consulted when you call
* getObject and there is no such resource in the current bundle.
*
* @param parent the parent of this bundle
*/
protected void setParent(ResourceBundle parent)
{
this.parent = parent;
}
/**
* Get the appropriate ResourceBundle for the default locale. This is like
* calling getBundle(baseName, Locale.getDefault(),
* getClass().getClassLoader(), except that any security check of
* getClassLoader won't fail.
*
* @param baseName the name of the ResourceBundle
* @return the desired resource bundle
* @throws MissingResourceException if the resource bundle can't be found
* @throws NullPointerException if baseName is null
*/
public static ResourceBundle getBundle(String baseName)
{
ClassLoader cl = VMStackWalker.getCallingClassLoader();
if (cl == null)
cl = ClassLoader.getSystemClassLoader();
return getBundle(baseName, Locale.getDefault(), cl);
}
/**
* Get the appropriate ResourceBundle for the given locale. This is like
* calling getBundle(baseName, locale,
* getClass().getClassLoader(), except that any security check of
* getClassLoader won't fail.
*
* @param baseName the name of the ResourceBundle
* @param locale A locale
* @return the desired resource bundle
* @throws MissingResourceException if the resource bundle can't be found
* @throws NullPointerException if baseName or locale is null
*/
public static ResourceBundle getBundle(String baseName, Locale locale)
{
ClassLoader cl = VMStackWalker.getCallingClassLoader();
if (cl == null)
cl = ClassLoader.getSystemClassLoader();
return getBundle(baseName, locale, cl);
}
/** Cache key for the ResourceBundle cache. Resource bundles are keyed
by the combination of bundle name, locale, and class loader. */
private static class BundleKey
{
Locale defaultLocale;
String baseName;
Locale locale;
ClassLoader classLoader;
int hashcode;
BundleKey() {}
BundleKey(Locale dl, String s, Locale l, ClassLoader cl)
{
set(dl, s, l, cl);
}
void set(Locale dl, String s, Locale l, ClassLoader cl)
{
defaultLocale = dl;
baseName = s;
locale = l;
classLoader = cl;
hashcode = defaultLocale.hashCode() ^ baseName.hashCode()
^ locale.hashCode() ^ classLoader.hashCode();
}
public int hashCode()
{
return hashcode;
}
public boolean equals(Object o)
{
if (! (o instanceof BundleKey))
return false;
BundleKey key = (BundleKey) o;
return hashcode == key.hashcode
&& defaultLocale.equals(key.defaultLocale)
&& baseName.equals(key.baseName)
&& locale.equals(key.locale)
&& classLoader.equals(key.classLoader);
}
public String toString()
{
CPStringBuilder builder = new CPStringBuilder(getClass().getName());
builder.append("[defaultLocale=");
builder.append(defaultLocale);
builder.append(",baseName=");
builder.append(baseName);
builder.append(",locale=");
builder.append(locale);
builder.append(",classLoader=");
builder.append(classLoader);
builder.append("]");
return builder.toString();
}
}
/** A cache lookup key. This avoids having to a new one for every
* getBundle() call. */
private static final BundleKey lookupKey = new BundleKey();
/** Singleton cache entry to represent previous failed lookups. */
private static final Object nullEntry = new Object();
/**
* Get the appropriate ResourceBundle for the given locale. The following
* strategy is used:
*
*
*
*
* getBundle tries to instantiate the resource bundle:
*
* If no resource bundle was found, a MissingResourceException is thrown.
*
* setParent method (unless the first bundle already
* has a parent).
*
*
* getObject. If you don't have a resource
* for the given key, you should return null instead throwing a
* MissingResourceException. You don't have to ask the parent, getObject()
* already does this; nor should you throw a MissingResourceException.
*
* @param key the key of the resource
* @return the resource for the key, or null if not in bundle
* @throws NullPointerException if key is null
*/
protected abstract Object handleGetObject(String key);
/**
* This method should return all keys for which a resource exists; you
* should include the enumeration of any parent's keys, after filtering out
* duplicates.
*
* @return an enumeration of the keys
*/
public abstract Enumeration