Java tutorial
/* * Copyright 2002-2018 the original author or authors. * * Licensed 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 * * https://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. */ package org.springframework.web.servlet.view; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.MissingResourceException; import java.util.ResourceBundle; import org.springframework.beans.BeansException; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.beans.factory.support.PropertiesBeanDefinitionReader; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.core.Ordered; import org.springframework.lang.Nullable; import org.springframework.web.context.support.GenericWebApplicationContext; import org.springframework.web.servlet.View; /** * A {@link org.springframework.web.servlet.ViewResolver} implementation that uses * bean definitions in a {@link ResourceBundle}, specified by the bundle basename. * * <p>The bundle is typically defined in a properties file, located in the classpath. * The default bundle basename is "views". * * <p>This {@code ViewResolver} supports localized view definitions, using the * default support of {@link java.util.PropertyResourceBundle}. For example, the * basename "views" will be resolved as class path resources "views_de_AT.properties", * "views_de.properties", "views.properties" - for a given Locale "de_AT". * * <p>Note: This {@code ViewResolver} implements the {@link Ordered} interface * in order to allow for flexible participation in {@code ViewResolver} chaining. * For example, some special views could be defined via this {@code ViewResolver} * (giving it 0 as "order" value), while all remaining views could be resolved by * a {@link UrlBasedViewResolver}. * * @author Rod Johnson * @author Juergen Hoeller * @see java.util.ResourceBundle#getBundle * @see java.util.PropertyResourceBundle * @see UrlBasedViewResolver */ public class ResourceBundleViewResolver extends AbstractCachingViewResolver implements Ordered, InitializingBean, DisposableBean { /** The default basename if no other basename is supplied. */ public static final String DEFAULT_BASENAME = "views"; private String[] basenames = new String[] { DEFAULT_BASENAME }; private ClassLoader bundleClassLoader = Thread.currentThread().getContextClassLoader(); @Nullable private String defaultParentView; @Nullable private Locale[] localesToInitialize; private int order = Ordered.LOWEST_PRECEDENCE; // default: same as non-Ordered /* Locale -> BeanFactory */ private final Map<Locale, BeanFactory> localeCache = new HashMap<>(); /* List of ResourceBundle -> BeanFactory */ private final Map<List<ResourceBundle>, ConfigurableApplicationContext> bundleCache = new HashMap<>(); /** * Set a single basename, following {@link java.util.ResourceBundle} conventions. * The default is "views". * <p>{@code ResourceBundle} supports different locale suffixes. For example, * a base name of "views" might map to {@code ResourceBundle} files * "views", "views_en_au" and "views_de". * <p>Note that ResourceBundle names are effectively classpath locations: As a * consequence, the JDK's standard ResourceBundle treats dots as package separators. * This means that "test.theme" is effectively equivalent to "test/theme", * just like it is for programmatic {@code java.util.ResourceBundle} usage. * @see #setBasenames * @see ResourceBundle#getBundle(String) * @see ResourceBundle#getBundle(String, Locale) */ public void setBasename(String basename) { setBasenames(basename); } /** * Set an array of basenames, each following {@link java.util.ResourceBundle} * conventions. The default is a single basename "views". * <p>{@code ResourceBundle} supports different locale suffixes. For example, * a base name of "views" might map to {@code ResourceBundle} files * "views", "views_en_au" and "views_de". * <p>The associated resource bundles will be checked sequentially when resolving * a message code. Note that message definitions in a <i>previous</i> resource * bundle will override ones in a later bundle, due to the sequential lookup. * <p>Note that ResourceBundle names are effectively classpath locations: As a * consequence, the JDK's standard ResourceBundle treats dots as package separators. * This means that "test.theme" is effectively equivalent to "test/theme", * just like it is for programmatic {@code java.util.ResourceBundle} usage. * @see #setBasename * @see ResourceBundle#getBundle(String) * @see ResourceBundle#getBundle(String, Locale) */ public void setBasenames(String... basenames) { this.basenames = basenames; } /** * Set the {@link ClassLoader} to load resource bundles with. * Default is the thread context {@code ClassLoader}. */ public void setBundleClassLoader(ClassLoader classLoader) { this.bundleClassLoader = classLoader; } /** * Return the {@link ClassLoader} to load resource bundles with. * <p>Default is the specified bundle {@code ClassLoader}, * usually the thread context {@code ClassLoader}. */ protected ClassLoader getBundleClassLoader() { return this.bundleClassLoader; } /** * Set the default parent for views defined in the {@code ResourceBundle}. * <p>This avoids repeated "yyy1.(parent)=xxx", "yyy2.(parent)=xxx" definitions * in the bundle, especially if all defined views share the same parent. * <p>The parent will typically define the view class and common attributes. * Concrete views might simply consist of an URL definition then: * a la "yyy1.url=/my.jsp", "yyy2.url=/your.jsp". * <p>View definitions that define their own parent or carry their own * class can still override this. Strictly speaking, the rule that a * default parent setting does not apply to a bean definition that * carries a class is there for backwards compatibility reasons. * It still matches the typical use case. */ public void setDefaultParentView(String defaultParentView) { this.defaultParentView = defaultParentView; } /** * Specify Locales to initialize eagerly, rather than lazily when actually accessed. * <p>Allows for pre-initialization of common Locales, eagerly checking * the view configuration for those Locales. */ public void setLocalesToInitialize(Locale... localesToInitialize) { this.localesToInitialize = localesToInitialize; } /** * Specify the order value for this ViewResolver bean. * <p>The default value is {@code Ordered.LOWEST_PRECEDENCE}, meaning non-ordered. * @see org.springframework.core.Ordered#getOrder() */ public void setOrder(int order) { this.order = order; } @Override public int getOrder() { return this.order; } /** * Eagerly initialize Locales if necessary. * @see #setLocalesToInitialize */ @Override public void afterPropertiesSet() throws BeansException { if (this.localesToInitialize != null) { for (Locale locale : this.localesToInitialize) { initFactory(locale); } } } @Override protected View loadView(String viewName, Locale locale) throws Exception { BeanFactory factory = initFactory(locale); try { return factory.getBean(viewName, View.class); } catch (NoSuchBeanDefinitionException ex) { // Allow for ViewResolver chaining... return null; } } /** * Initialize the View {@link BeanFactory} from the {@code ResourceBundle}, * for the given {@link Locale locale}. * <p>Synchronized because of access by parallel threads. * @param locale the target {@code Locale} * @return the View factory for the given Locale * @throws BeansException in case of initialization errors */ protected synchronized BeanFactory initFactory(Locale locale) throws BeansException { // Try to find cached factory for Locale: // Have we already encountered that Locale before? if (isCache()) { BeanFactory cachedFactory = this.localeCache.get(locale); if (cachedFactory != null) { return cachedFactory; } } // Build list of ResourceBundle references for Locale. List<ResourceBundle> bundles = new LinkedList<>(); for (String basename : this.basenames) { ResourceBundle bundle = getBundle(basename, locale); bundles.add(bundle); } // Try to find cached factory for ResourceBundle list: // even if Locale was different, same bundles might have been found. if (isCache()) { BeanFactory cachedFactory = this.bundleCache.get(bundles); if (cachedFactory != null) { this.localeCache.put(locale, cachedFactory); return cachedFactory; } } // Create child ApplicationContext for views. GenericWebApplicationContext factory = new GenericWebApplicationContext(); factory.setParent(getApplicationContext()); factory.setServletContext(getServletContext()); // Load bean definitions from resource bundle. PropertiesBeanDefinitionReader reader = new PropertiesBeanDefinitionReader(factory); reader.setDefaultParentBean(this.defaultParentView); for (ResourceBundle bundle : bundles) { reader.registerBeanDefinitions(bundle); } factory.refresh(); // Cache factory for both Locale and ResourceBundle list. if (isCache()) { this.localeCache.put(locale, factory); this.bundleCache.put(bundles, factory); } return factory; } /** * Obtain the resource bundle for the given basename and {@link Locale}. * @param basename the basename to look for * @param locale the {@code Locale} to look for * @return the corresponding {@code ResourceBundle} * @throws MissingResourceException if no matching bundle could be found * @see ResourceBundle#getBundle(String, Locale, ClassLoader) */ protected ResourceBundle getBundle(String basename, Locale locale) throws MissingResourceException { return ResourceBundle.getBundle(basename, locale, getBundleClassLoader()); } /** * Close the bundle View factories on context shutdown. */ @Override public void destroy() throws BeansException { for (ConfigurableApplicationContext factory : this.bundleCache.values()) { factory.close(); } this.localeCache.clear(); this.bundleCache.clear(); } }