Java tutorial
/* * Copyright 2002-2017 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 * * 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. */ package org.springframework.context.support; import java.text.MessageFormat; import java.util.HashMap; import java.util.Locale; import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.lang.Nullable; import org.springframework.util.ObjectUtils; /** * Base class for message source implementations, providing support infrastructure * such as {@link java.text.MessageFormat} handling but not implementing concrete * methods defined in the {@link org.springframework.context.MessageSource}. * * <p>{@link AbstractMessageSource} derives from this class, providing concrete * {@code getMessage} implementations that delegate to a central template * method for message code resolution. * * @author Juergen Hoeller * @since 2.5.5 */ public abstract class MessageSourceSupport { private static final MessageFormat INVALID_MESSAGE_FORMAT = new MessageFormat(""); /** Logger available to subclasses */ protected final Log logger = LogFactory.getLog(getClass()); private boolean alwaysUseMessageFormat = false; /** * Cache to hold already generated MessageFormats per message. * Used for passed-in default messages. MessageFormats for resolved * codes are cached on a specific basis in subclasses. */ private final Map<String, Map<Locale, MessageFormat>> messageFormatsPerMessage = new HashMap<>(); /** * Set whether to always apply the {@code MessageFormat} rules, * parsing even messages without arguments. * <p>Default is "false": Messages without arguments are by default * returned as-is, without parsing them through MessageFormat. * Set this to "true" to enforce MessageFormat for all messages, * expecting all message texts to be written with MessageFormat escaping. * <p>For example, MessageFormat expects a single quote to be escaped * as "''". If your message texts are all written with such escaping, * even when not defining argument placeholders, you need to set this * flag to "true". Else, only message texts with actual arguments * are supposed to be written with MessageFormat escaping. * @see java.text.MessageFormat */ public void setAlwaysUseMessageFormat(boolean alwaysUseMessageFormat) { this.alwaysUseMessageFormat = alwaysUseMessageFormat; } /** * Return whether to always apply the MessageFormat rules, parsing even * messages without arguments. */ protected boolean isAlwaysUseMessageFormat() { return this.alwaysUseMessageFormat; } /** * Render the given default message String. The default message is * passed in as specified by the caller and can be rendered into * a fully formatted default message shown to the user. * <p>The default implementation passes the String to {@code formatMessage}, * resolving any argument placeholders found in them. Subclasses may override * this method to plug in custom processing of default messages. * @param defaultMessage the passed-in default message String * @param args array of arguments that will be filled in for params within * the message, or {@code null} if none. * @param locale the Locale used for formatting * @return the rendered default message (with resolved arguments) * @see #formatMessage(String, Object[], java.util.Locale) */ protected String renderDefaultMessage(String defaultMessage, @Nullable Object[] args, Locale locale) { return formatMessage(defaultMessage, args, locale); } /** * Format the given message String, using cached MessageFormats. * By default invoked for passed-in default messages, to resolve * any argument placeholders found in them. * @param msg the message to format * @param args array of arguments that will be filled in for params within * the message, or {@code null} if none * @param locale the Locale used for formatting * @return the formatted message (with resolved arguments) */ protected String formatMessage(String msg, @Nullable Object[] args, Locale locale) { if (!isAlwaysUseMessageFormat() && ObjectUtils.isEmpty(args)) { return msg; } MessageFormat messageFormat = null; synchronized (this.messageFormatsPerMessage) { Map<Locale, MessageFormat> messageFormatsPerLocale = this.messageFormatsPerMessage.get(msg); if (messageFormatsPerLocale != null) { messageFormat = messageFormatsPerLocale.get(locale); } else { messageFormatsPerLocale = new HashMap<>(); this.messageFormatsPerMessage.put(msg, messageFormatsPerLocale); } if (messageFormat == null) { try { messageFormat = createMessageFormat(msg, locale); } catch (IllegalArgumentException ex) { // Invalid message format - probably not intended for formatting, // rather using a message structure with no arguments involved... if (isAlwaysUseMessageFormat()) { throw ex; } // Silently proceed with raw message if format not enforced... messageFormat = INVALID_MESSAGE_FORMAT; } messageFormatsPerLocale.put(locale, messageFormat); } } if (messageFormat == INVALID_MESSAGE_FORMAT) { return msg; } synchronized (messageFormat) { return messageFormat.format(resolveArguments(args, locale)); } } /** * Create a MessageFormat for the given message and Locale. * @param msg the message to create a MessageFormat for * @param locale the Locale to create a MessageFormat for * @return the MessageFormat instance */ protected MessageFormat createMessageFormat(String msg, Locale locale) { return new MessageFormat(msg, locale); } /** * Template method for resolving argument objects. * <p>The default implementation simply returns the given argument array as-is. * Can be overridden in subclasses in order to resolve special argument types. * @param args the original argument array * @param locale the Locale to resolve against * @return the resolved argument array */ protected Object[] resolveArguments(@Nullable Object[] args, Locale locale) { return (args != null ? args : new Object[0]); } }