| package org.apache.fulcrum.localization; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import java.text.MessageFormat; |
| import java.util.HashMap; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.MissingResourceException; |
| import java.util.ResourceBundle; |
| |
| import org.apache.avalon.framework.activity.Initializable; |
| import org.apache.avalon.framework.configuration.Configurable; |
| import org.apache.avalon.framework.configuration.Configuration; |
| import org.apache.avalon.framework.configuration.ConfigurationException; |
| import org.apache.avalon.framework.logger.AbstractLogEnabled; |
| import org.apache.commons.lang3.StringUtils; |
| |
| /** |
| * <p> |
| * This class is the single point of access to all localization |
| * resources. It caches different ResourceBundles for different |
| * Locales. |
| * </p> |
| * |
| * <p>Usage example:</p> |
| * |
| * <pre> |
| * <code> |
| * SimpleLocalizationService ls = (SimpleLocalizationService) TurbineServices |
| * .getInstance().getService(SimpleLocalizationService.SERVICE_NAME); |
| * </code> |
| * </pre> |
| * |
| * <p> |
| * Then call {@link #getString(String, Locale, String)}, or one of |
| * two methods to retrieve a ResourceBundle: |
| * </p> |
| * |
| * <ul> |
| * <li>getBundle("MyBundleName")</li> |
| * <li>getBundle("MyBundleName", Locale)</li> |
| * <li>etc.</li> |
| * </ul> |
| * |
| * @author <a href="mailto:jm@mediaphil.de">Jonas Maurus</a> |
| * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a> |
| * @author <a href="mailto:novalidemail@foo.com">Frank Y. Kim</a> |
| * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a> |
| * @author <a href="mailto:leonardr@collab.net">Leonard Richardson</a> |
| * @author <a href="mailto:mcconnell@apache.org">Stephen McConnell</a> |
| * @author <a href="mailto:tv@apache.org">Thomas Vandahl</a> |
| * @version $Id: DefaultLocalizationService.java 535465 2007-05-05 06:58:06Z tv $ |
| * |
| * avalon.component name="localization" lifestyle="singleton" |
| * avalon.service type="org.apache.fulcrum.localization.SimpleLocalizationService" |
| */ |
| public class SimpleLocalizationServiceImpl |
| extends AbstractLogEnabled |
| implements SimpleLocalizationService, Configurable, Initializable |
| { |
| /** Key Prefix for our bundles */ |
| private static final String BUNDLES = "bundles"; |
| |
| /** |
| * The value to pass to <code>MessageFormat</code> if a |
| * <code>null</code> reference is passed to <code>format()</code>. |
| */ |
| private static final Object[] NO_ARGS = new Object[0]; |
| |
| /** |
| * Bundle name keys a HashMap of the ResourceBundles in this |
| * service (which is in turn keyed by Locale). |
| */ |
| private HashMap<String, HashMap<Locale, ResourceBundle>> bundles = null; |
| |
| /** |
| * The list of default bundles to search. |
| */ |
| private String[] bundleNames = null; |
| |
| /** |
| * The name of the default locale to use (includes language and |
| * country). |
| */ |
| private Locale defaultLocale = null; |
| |
| /** The name of the default language to use. */ |
| private String defaultLanguage = null; |
| |
| /** The name of the default country to use. */ |
| private String defaultCountry = null; |
| |
| /** |
| * Creates a new instance. |
| */ |
| public SimpleLocalizationServiceImpl() |
| { |
| bundles = new HashMap<String, HashMap<Locale, ResourceBundle>>(); |
| } |
| |
| /** |
| * Avalon lifecycle method |
| * |
| * {@link org.apache.avalon.framework.configuration.Configurable} |
| * |
| * @param conf the configuration |
| * @throws ConfigurationException if failed to configure |
| */ |
| @Override |
| public void configure(Configuration conf) throws ConfigurationException |
| { |
| Locale jvmDefault = Locale.getDefault(); |
| defaultLanguage = |
| conf |
| .getAttribute( |
| "locale-default-language", |
| jvmDefault.getLanguage()) |
| .trim(); |
| defaultCountry = |
| conf |
| .getAttribute("locale-default-country", jvmDefault.getCountry()) |
| .trim(); |
| // FIXME! need to add bundle names |
| getLogger().info( |
| "initialized lang=" |
| + defaultLanguage |
| + " country=" |
| + defaultCountry); |
| final Configuration bundles = conf.getChild(BUNDLES, false); |
| if (bundles != null) |
| { |
| Configuration[] nameVal = bundles.getChildren(); |
| String bundleName[] = new String[nameVal.length]; |
| for (int i = 0; i < nameVal.length; i++) |
| { |
| String val = nameVal[i].getValue(); |
| getLogger().debug("Registered bundle " + val); |
| bundleName[i] = val; |
| } |
| initBundleNames(bundleName); |
| } |
| } |
| |
| /** |
| * Called the first time the Service is used. |
| * |
| * @throws Exception generic exception |
| */ |
| @Override |
| public void initialize() throws Exception |
| { |
| defaultLocale = new Locale(defaultLanguage, defaultCountry); |
| if (getLogger().isInfoEnabled()) |
| { |
| getLogger().info("Localization Service is Initialized now.."); |
| } |
| } |
| |
| /** |
| * Initialize list of default bundle names. |
| * |
| * @param intBundleNames set bundle names |
| */ |
| protected void initBundleNames(String[] intBundleNames) |
| { |
| if (intBundleNames == null) |
| bundleNames = new String[0]; |
| else |
| bundleNames = intBundleNames; |
| } |
| |
| /** |
| * Retrieves the default language (specified in the config file). |
| * |
| * @return the default language |
| */ |
| @Override |
| public String getDefaultLanguage() |
| { |
| return defaultLanguage; |
| } |
| |
| /** |
| * Retrieves the default country (specified in the config file). |
| * |
| * @return the default country |
| */ |
| @Override |
| public String getDefaultCountry() |
| { |
| return defaultCountry; |
| } |
| |
| /** |
| * Retrieves the default Locale (as created from default |
| * language and default country). |
| * |
| * @return the default locale |
| */ |
| @Override |
| public Locale getDefaultLocale() |
| { |
| return defaultLocale; |
| } |
| |
| /** |
| * {@link org.apache.fulcrum.localization.SimpleLocalizationService#getDefaultBundleName()} |
| * |
| * @return the default bundle name |
| */ |
| @Override |
| public String getDefaultBundleName() |
| { |
| return (bundleNames.length > 0 ? bundleNames[0] : ""); |
| } |
| |
| /** |
| * {@link org.apache.fulcrum.localization.SimpleLocalizationService#getBundleNames()} |
| * |
| * @return list of bundle names available |
| */ |
| @Override |
| public String[] getBundleNames() |
| { |
| return bundleNames.clone(); |
| } |
| |
| /** |
| * @see org.apache.fulcrum.localization.SimpleLocalizationService#getBundle() |
| * |
| * @return the default resource bundle |
| */ |
| @Override |
| public ResourceBundle getBundle() |
| { |
| return getBundle(getDefaultBundleName(), (Locale) null); |
| } |
| |
| /** |
| * @see org.apache.fulcrum.localization.SimpleLocalizationService#getBundle(java.lang.String) |
| * |
| * @param bundleName the name of a bundle |
| * @return the resource bundle |
| */ |
| @Override |
| public ResourceBundle getBundle(String bundleName) |
| { |
| return getBundle(bundleName, (Locale) null); |
| } |
| |
| /** |
| * @see org.apache.fulcrum.localization.SimpleLocalizationService#getBundle(java.lang.String, java.util.Locale) |
| * |
| * This method returns a ResourceBundle for the given bundle name |
| * and the given Locale. |
| * |
| * @param bundleName Name of bundle (or <code>null</code> for the |
| * default bundle). |
| * @param locale The locale (or <code>null</code> for the locale |
| * indicated by the default language and country). |
| * @return A localized ResourceBundle. |
| */ |
| @Override |
| public ResourceBundle getBundle(String bundleName, Locale locale) |
| { |
| // Assure usable inputs. |
| bundleName = |
| (bundleName == null ? getDefaultBundleName() : bundleName.trim()); |
| if (locale == null) |
| { |
| locale = getDefaultLocale(); |
| } |
| // Find/retrieve/cache bundle. |
| ResourceBundle rb = null; |
| HashMap<?, ?> bundlesByLocale = (HashMap<?, ?>) bundles.get(bundleName); |
| if (bundlesByLocale != null) |
| { |
| // Cache of bundles by locale for the named bundle exists. |
| // Check the cache for a bundle corresponding to locale. |
| rb = (ResourceBundle) bundlesByLocale.get(locale); |
| if (rb == null) |
| { |
| // Not yet cached. |
| rb = cacheBundle(bundleName, locale); |
| } |
| } |
| else |
| { |
| rb = cacheBundle(bundleName, locale); |
| } |
| return rb; |
| } |
| |
| /** |
| * Caches the named bundle for fast lookups. This operation is |
| * relatively expensive in terms of memory use, but is optimized |
| * for run-time speed in the usual case. |
| * |
| * @param bundleName Name of bundle (or <code>null</code> for the |
| * default bundle). |
| * @param locale The locale (or <code>null</code> for the locale |
| * indicated by the default language and country). |
| * @throws MissingResourceException Bundle not found. |
| * @return a localized resource bundle |
| */ |
| private synchronized ResourceBundle cacheBundle( |
| String bundleName, |
| Locale locale) |
| throws MissingResourceException |
| { |
| HashMap<Locale, ResourceBundle> bundlesByLocale = (HashMap<Locale, ResourceBundle>) bundles.get(bundleName); |
| ResourceBundle rb = |
| (bundlesByLocale == null |
| ? null |
| : (ResourceBundle) bundlesByLocale.get(locale)); |
| if (rb == null) |
| { |
| bundlesByLocale = |
| (bundlesByLocale == null |
| ? new HashMap<Locale, ResourceBundle>(3) |
| : new HashMap<Locale, ResourceBundle>(bundlesByLocale)); |
| try |
| { |
| rb = ResourceBundle.getBundle(bundleName, locale); |
| } |
| catch (MissingResourceException e) |
| { |
| rb = findBundleByLocale(bundleName, locale, bundlesByLocale); |
| if (rb == null) |
| { |
| throw (MissingResourceException) e.fillInStackTrace(); |
| } |
| } |
| if (rb != null) |
| { |
| // Cache bundle. |
| bundlesByLocale.put(rb.getLocale(), rb); |
| HashMap<String, HashMap<Locale, ResourceBundle>> bundlesByName |
| = new HashMap<String, HashMap<Locale, ResourceBundle>>(bundles); |
| bundlesByName.put(bundleName, bundlesByLocale); |
| this.bundles = bundlesByName; |
| } |
| } |
| return rb; |
| } |
| |
| /** |
| * <p>Retrieves the bundle most closely matching first against the |
| * supplied inputs, then against the defaults.</p> |
| * |
| * <p>Use case: some clients send a HTTP Accept-Language header |
| * with a value of only the language to use |
| * (i.e. "Accept-Language: en"), and neglect to include a country. |
| * When there is no bundle for the requested language, this method |
| * can be called to try the default country (checking internally |
| * to assure the requested criteria matches the default to avoid |
| * disconnects between language and country).</p> |
| * |
| * <p>Since we're really just guessing at possible bundles to use, |
| * we don't ever throw <code>MissingResourceException</code>.</p> |
| * |
| * @param bundleName Name of bundle (or <code>null</code> for the |
| * default bundle). |
| * @param locale The locale (or <code>null</code> for the locale |
| * indicated by the default language and country). |
| * @param bundleByLocale map of locales and resource bundles |
| * @return a localized resource bundle |
| * |
| */ |
| private ResourceBundle findBundleByLocale( |
| String bundleName, |
| Locale locale, |
| Map<Locale, ResourceBundle> bundlesByLocale) |
| { |
| ResourceBundle rb = null; |
| if (StringUtils.isEmpty(locale.getCountry()) |
| && defaultLanguage.equals(locale.getLanguage())) |
| { |
| /* |
| * category.debug("Requested language '" + locale.getLanguage() + |
| * "' matches default: Attempting to guess bundle " + |
| * "using default country '" + defaultCountry + '\''); |
| */ |
| Locale withDefaultCountry = |
| new Locale(locale.getLanguage(), defaultCountry); |
| rb = (ResourceBundle) bundlesByLocale.get(withDefaultCountry); |
| if (rb == null) |
| { |
| rb = getBundleIgnoreException(bundleName, withDefaultCountry); |
| } |
| } |
| else if ( |
| StringUtils.isEmpty(locale.getLanguage()) |
| && defaultCountry.equals(locale.getCountry())) |
| { |
| Locale withDefaultLanguage = |
| new Locale(defaultLanguage, locale.getCountry()); |
| rb = (ResourceBundle) bundlesByLocale.get(withDefaultLanguage); |
| if (rb == null) |
| { |
| rb = getBundleIgnoreException(bundleName, withDefaultLanguage); |
| } |
| } |
| |
| if (rb == null && !defaultLocale.equals(locale)) |
| { |
| rb = getBundleIgnoreException(bundleName, defaultLocale); |
| } |
| return rb; |
| } |
| |
| /** |
| * Retrieves the bundle using the |
| * <code>ResourceBundle.getBundle(String, Locale)</code> method, |
| * returning <code>null</code> instead of throwing |
| * <code>MissingResourceException</code>. |
| * |
| * @param bundleName Name of bundle (or <code>null</code> for the |
| * default bundle). |
| * @param locale The locale (or <code>null</code> for the locale |
| * indicated by the default language and country). |
| */ |
| private final ResourceBundle getBundleIgnoreException( |
| String bundleName, |
| Locale locale) |
| { |
| try |
| { |
| return ResourceBundle.getBundle(bundleName, locale); |
| } |
| catch (MissingResourceException ignored) |
| { |
| return null; |
| } |
| } |
| |
| /** |
| * This method sets the name of the first bundle in the search |
| * list (the "default" bundle). |
| * |
| * @param defaultBundle Name of default bundle. |
| */ |
| @Override |
| public void setBundle(String defaultBundle) |
| { |
| if (bundleNames.length > 0) |
| { |
| bundleNames[0] = defaultBundle; |
| } |
| else |
| { |
| synchronized (this) |
| { |
| if (bundleNames.length <= 0) |
| { |
| bundleNames = new String[] { defaultBundle }; |
| } |
| } |
| } |
| } |
| |
| /** |
| * |
| * {@link org.apache.fulcrum.localization.SimpleLocalizationService#getString(String, Locale, String)} |
| * @throws MissingResourceException Specified key cannot be matched. |
| */ |
| @Override |
| public String getString(String bundleName, Locale locale, String key) |
| throws MissingResourceException |
| { |
| String value = null; |
| if (locale == null) |
| { |
| locale = getDefaultLocale(); |
| } |
| // Look for text in requested bundle. |
| ResourceBundle rb = getBundle(bundleName, locale); |
| value = getStringOrNull(rb, key); |
| // Look for text in list of default bundles. |
| if (value == null && bundleNames.length > 0) |
| { |
| String name; |
| for (int i = 0; i < bundleNames.length; i++) |
| { |
| name = bundleNames[i]; |
| //System.out.println("getString(): name=" + name + |
| // ", locale=" + locale + ", i=" + i); |
| if (!name.equals(bundleName)) |
| { |
| rb = getBundle(name, locale); |
| value = getStringOrNull(rb, key); |
| if (value != null) |
| { |
| locale = rb.getLocale(); |
| break; |
| } |
| } |
| } |
| } |
| if (value == null) |
| { |
| String loc = locale.toString(); |
| String mesg = |
| LocalizationService.SERVICE_NAME |
| + " noticed missing resource: " |
| + "bundleName=" |
| + bundleName |
| + ", locale=" |
| + loc |
| + ", key=" |
| + key; |
| getLogger().debug(mesg); |
| // Text not found in requested or default bundles. |
| throw new MissingResourceException(mesg, bundleName, key); |
| } |
| return value; |
| } |
| |
| /** |
| * Returns the value for the key in the default bundle and the default locale. |
| * |
| * @param key The key to retrieve the value for. |
| * @return The value mapped to the key. |
| */ |
| @Override |
| public String getString(String key) |
| { |
| return getString(getDefaultBundleName(), getDefaultLocale(), key); |
| } |
| |
| |
| /** |
| * Gets localized text from a bundle if it's there. Otherwise, |
| * returns <code>null</code> (ignoring a possible |
| * <code>MissingResourceException</code>). |
| * |
| * @param rb resource bundle |
| * @param key The key to retrieve the value for. |
| * @return name of resource |
| */ |
| protected final String getStringOrNull(ResourceBundle rb, String key) |
| { |
| if (rb != null) |
| { |
| try |
| { |
| return rb.getString(key); |
| } |
| catch (MissingResourceException ignored) |
| { |
| // ignore |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * {@link org.apache.fulcrum.localization.SimpleLocalizationService#format(String, Locale, String, Object)} |
| * @param bundleName the bundle name |
| * @param locale locale |
| * @param key key to lookup |
| * @param arg1 bundle arguments |
| */ |
| @Override |
| public String format( |
| String bundleName, |
| Locale locale, |
| String key, |
| Object arg1) |
| { |
| return format(bundleName, locale, key, new Object[] { arg1 }); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.apache.fulcrum.localization.SimpleLocalizationService#format(java.lang.String, java.util.Locale, java.lang.String, java.lang.Object, java.lang.Object) |
| */ |
| @Override |
| public String format( |
| String bundleName, |
| Locale locale, |
| String key, |
| Object arg1, |
| Object arg2) |
| { |
| return format(bundleName, locale, key, new Object[] { arg1, arg2 }); |
| } |
| |
| /** |
| * Looks up the value for <code>key</code> in the |
| * <code>ResourceBundle</code> referenced by |
| * <code>bundleName</code>, then formats that value for the |
| * specified <code>Locale</code> using <code>args</code>. |
| * |
| * If <code>locale</code> is <code>null</code>, {@link #getDefaultLocale()} will be checked. |
| * If <code>bundleName</code> is <code>null</code>, {@link #getDefaultBundleName()} will be checked (cft. {@link #getBundle(String, Locale)}. |
| * |
| * @return Localized, formatted text identified by |
| * <code>key</code>. |
| */ |
| @Override |
| public String format( |
| String bundleName, |
| Locale locale, |
| String key, |
| Object[] args) |
| { |
| // When formatting Date objects and such, MessageFormat |
| // cannot have a null Locale. |
| Locale formatLocale = (locale == null) ? getDefaultLocale() : locale; |
| String value = getString(bundleName, locale, key); |
| |
| Object[] formatArgs = (args == null) ? NO_ARGS : args; |
| |
| MessageFormat messageFormat = new MessageFormat(value, formatLocale); |
| return messageFormat.format(formatArgs); |
| } |
| } |
