灵小帝
灵小帝

Spring之国际化信息MessageSource源码阅读

MessageSource架构图

Spring之国际化信息MessageSource源码阅读_第1张图片
1. MessageSource：抽象化的消息接口
2. HierarchicalMessageSource：分层的消息源接口，可获取父消息源
3. MessageSourceSupport：帮助消息源解析的抽象类,通过指定“消息格式化组件MessageFormat”格式化消息。
4. DelegatingMessageSource： 消息源解析委派类（用户未指定时，SpringContext默认使用当前类),功能比较简单：将字符串和参数数组格式化为一个消息字符串
5. AbstractMessageSource：支持‘配置文件’的方式国际化资源 的 抽象类，内部提供一个与区域设置无关的公共消息配置文件，消息代码为关键字。
6. StaticMessageSource：主要用于程序测试，它允许通过编程的方式提供国际化信息
7. ResourceBundleMessageSource：该实现类允许用户通过beanName指定一个资源名（包括类路径的全限定资源名），或通过beanNames指定一组资源名。不同的区域获取加载资源文件，达到国际化信息的目的。
8. ReloadableResourceBundleMessageSource：同ResourceBundleMessageSource区别(spring3.2):
1)加载资源类型及方式:
ResourceBundleMessageSource 依托JDK自带ResourceBundle加载资源，支持绝对路径和工程路径，支持文件为.class文件和.properties。
ReloadResourceBundleMessageSource依托spring的ResourceLoader加载Resource资源,功能更加强大，同时支持.properties和.xml文件。
2)缓存时间：
ResourceBundleMessageSource主要利用ResourceBundle.Control 实现简单的自动重载。
ReloadResourceBundleMessageSource每次加载资源都会记录每个资源的加载时间点，在缓存资源过期后会再次比较文件的修改时间，如果不变则不需要重新加载，同时刷新本次加载时间点。
3)编码方式：
ResourceBundleMessageSource可以统一指定默认的文件编码方式
ReloadResourceBundleMessageSource不仅可以指定统一的默认编码方式，也同时支持为每个文件单独制定编码方式

spring中初始化MessageSource组件

//springContext国际化资源信息初始化。这里的messageSource主要是将这个Bean定义的信息资源加载为容器级的国际化信息资源。
public abstract class AbstractApplicationContext extends DefaultResourceLoader
        implements ConfigurableApplicationContext, DisposableBean {

    public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";

    /** 实际委托的消息源解析对象 */
    private MessageSource messageSource;

    //======省略一段代码========／
    public void refresh() throws BeansException, IllegalStateException {

        //======省略一段代码========／

        // 初始化此上下文的消息源。
        initMessageSource();

        // Initialize event multicaster for this context.
        initApplicationEventMulticaster();

        //======省略一段代码========／
    }

    //======省略一段代码========／


    /**
     * 初始化此上下文的消息源。
     * 如果没有在此上下文中定义，请使用父级。
     */
    protected void initMessageSource() {
        //获取工厂
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        //先找工厂中messageSource是否有对应的实例（注册过）
        if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
            this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
            //messageSource是否有父消息源
            if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
                HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
                if (hms.getParentMessageSource() == null) {
                    // 父MessageSource未注册，则设置messageSource的parentMessageSource为“父上下文的‘MessageSource’ ”。
                    hms.setParentMessageSource(getInternalParentMessageSource());
                }
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Using MessageSource [" + this.messageSource + "]");
            }
        }
        else {//没有对应的实例，则自己初始化一个
            // 实例化一个spring默认实现消息源对象
            DelegatingMessageSource dms = new DelegatingMessageSource();
            //设置父消息源
            dms.setParentMessageSource(getInternalParentMessageSource());
            this.messageSource = dms;
            //‘单例模式’注册到工厂中
            beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
            if (logger.isDebugEnabled()) {
                logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
                        "': using default [" + this.messageSource + "]");
            }
        }
    }
    //获取父上下文的消息源
    protected MessageSource getInternalParentMessageSource() {
        return (getParent() instanceof AbstractApplicationContext) ?
            ((AbstractApplicationContext) getParent()).messageSource : getParent();
    }
}

各个类源码阅读

MessageSource接口

public interface MessageSource {

    /**
     * 尝试解决消息。 如果没有找到消息，返回默认消息。
     */
    String getMessage(String code, Object[] args, String defaultMessage, Locale locale);

    /**
     * 尝试解决消息。 如果无法找到消息，则视为错误。
     */
    String getMessage(String code, Object[] args, Locale locale) throws NoSuchMessageException;

    /**
     * 尝试使用传入的{@code MessageSourceResolvable}参数中包含的所有属性来解析消息。
     * 
NOTE: 我们必须在此方法上抛出{@code NoSuchMessageException}，因为在调用此方法时，我们无法确定可解析的{@code defaultMessage}属性是否为空。
     */
    String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException;

}

MessageSourceResolvable解析消息要素的包装接口和类

//解析消息要素的包装类：code、Arguments、默认消息
public interface MessageSourceResolvable {

    /**
     * 返回用于解决此消息的代码，按照他们应该尝试的顺序。 因此，最后一个代码将是默认代码。
     * @return a String array of codes which are associated with this message
     */
    String[] getCodes();

    /**
     * 返回要用于解析此消息的参数数组。
     * @return an array of objects to be used as parameters to replace
     * placeholders within the message text
     * @see java.text.MessageFormat
     */
    Object[] getArguments();

    /**
     * 返回要用于解析此消息的默认消息。
     * @return the default message, or {@code null} if no default
     */
    String getDefaultMessage();

}

//spring默认实现的 解析消息要素的包装类
public class DefaultMessageSourceResolvable implements MessageSourceResolvable, Serializable {

    private final String[] codes;

    private final Object[] arguments;

    private final String defaultMessage;


    //构造方法
    public DefaultMessageSourceResolvable(String code) {
        this(new String[] {code}, null, null);
    }
    //构造方法
    public DefaultMessageSourceResolvable(String[] codes) {
        this(codes, null, null);
    }

    //构造方法
    public DefaultMessageSourceResolvable(String[] codes, String defaultMessage) {
        this(codes, null, defaultMessage);
    }
    //构造方法
    public DefaultMessageSourceResolvable(String[] codes, Object[] arguments) {
        this(codes, arguments, null);
    }

    //构造方法
    public DefaultMessageSourceResolvable(String[] codes, Object[] arguments, String defaultMessage) {
        this.codes = codes;
        this.arguments = arguments;
        this.defaultMessage = defaultMessage;
    }
    //构造方法
    public DefaultMessageSourceResolvable(MessageSourceResolvable resolvable) {
        this(resolvable.getCodes(), resolvable.getArguments(), resolvable.getDefaultMessage());
    }


    public String[] getCodes() {
        return this.codes;
    }

    /**
     * 返回此可解析的默认代码，即代码数组中的最后一个代码。
     */
    public String getCode() {
        return (this.codes != null && this.codes.length > 0) ? this.codes[this.codes.length - 1] : null;
    }

    public Object[] getArguments() {
        return this.arguments;
    }

    public String getDefaultMessage() {
        return this.defaultMessage;
    }


    /**
     * 为此MessageSourceResolvable构建默认的String表示形式：包括代码，参数和默认消息。
     */
    protected final String resolvableToString() {
        StringBuilder result = new StringBuilder();
        result.append("codes [").append(StringUtils.arrayToDelimitedString(this.codes, ","));
        result.append("]; arguments [" + StringUtils.arrayToDelimitedString(this.arguments, ","));
        result.append("]; default message [").append(this.defaultMessage).append(']');
        return result.toString();
    }

    /**默认实现公开了此MessageSourceResolvable的属性。要在更具体的子类中被覆盖，可能通过{@code resolvableToString（）}包含可解析的内容。
     * @see #resolvableToString()
     */
    @Override
    public String toString() {
        return getClass().getName() + ": " + resolvableToString();
    }


    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof MessageSourceResolvable)) {
            return false;
        }
        MessageSourceResolvable otherResolvable = (MessageSourceResolvable) other;
        return ObjectUtils.nullSafeEquals(getCodes(), otherResolvable.getCodes()) &&
                ObjectUtils.nullSafeEquals(getArguments(), otherResolvable.getArguments()) &&
                ObjectUtils.nullSafeEquals(getDefaultMessage(), otherResolvable.getDefaultMessage());
    }

    @Override
    public int hashCode() {
        int hashCode = ObjectUtils.nullSafeHashCode(getCodes());
        hashCode = 29 * hashCode + ObjectUtils.nullSafeHashCode(getArguments());
        hashCode = 29 * hashCode + ObjectUtils.nullSafeHashCode(getDefaultMessage());
        return hashCode;
    }

}

HierarchicalMessageSource消息源分层接口

public interface HierarchicalMessageSource extends MessageSource {

    /**
     * 设置将用于尝试解决此对象无法解析的消息的父级。
     * @param parent 将用于解析此对象无法解析的邮件的父MessageSource。 可能是{@code null}，在这种情况下不需要进一步的解决。
     */
    void setParentMessageSource(MessageSource parent);

    /**
     * 返回此MessageSource的父级，否则返回{@code null}。
     */
    MessageSource getParentMessageSource();

}

MessageSourceSupport

//用于支撑消息源解析的抽象类
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;


    //缓存来保存已解决消息msg的’消息格式组件‘。 用于传入的默认消息（如：AbstractMessageSource中的commonMessages中的消息）。 
    private final Map> messageFormatsPerMessage =
            new HashMap>();


    /**
     * 设置是否始终应用’消息格式组件‘，解析没有参数的消息。
     * 
例如：,MessageFormat希望单引号被转义为"''"。 如果您的消息文本全部用这样的转义编写，
     * 即使没有定义参数占位符，您需要将此标志设置为“true”。 
     * 否则，只有具有实际参数的消息文本应该用MessageFormat转义来编写。
     * @see java.text.MessageFormat
     */
    public void setAlwaysUseMessageFormat(boolean alwaysUseMessageFormat) {
        this.alwaysUseMessageFormat = alwaysUseMessageFormat;
    }

    /**
     * 返回是否始终应用’消息格式组件‘，解析没有参数的消息。
     */
    protected boolean isAlwaysUseMessageFormat() {
        return this.alwaysUseMessageFormat;
    }


    //渲染给定的默认消息字符串。 
    protected String renderDefaultMessage(String defaultMessage, Object[] args, Locale locale) {
        return formatMessage(defaultMessage, args, locale);
    }

    //渲染给定的消息字符串。 
    protected String formatMessage(String msg, Object[] args, Locale locale) {
        if (msg == null || (!this.alwaysUseMessageFormat && ObjectUtils.isEmpty(args))) {
            return msg;
        }
        MessageFormat messageFormat = null;
        synchronized (this.messageFormatsPerMessage) { //防止并发操作
            //先尝试取缓存’消息格式组件‘
            Map messageFormatsPerLocale = this.messageFormatsPerMessage.get(msg);
            if (messageFormatsPerLocale != null) {
                messageFormat = messageFormatsPerLocale.get(locale);
            }
            else {//缓存为空，设置初始化空map值
                messageFormatsPerLocale = new HashMap();
                this.messageFormatsPerMessage.put(msg, messageFormatsPerLocale);
            }
            //’消息格式组件‘为空，则初始化一个messageFormat
            if (messageFormat == null) {
                try {
                    messageFormat = createMessageFormat(msg, locale);
                }
                catch (IllegalArgumentException ex) {
                    // 如果alwaysUseMessageFormat为true，即抛错
                    if (this.alwaysUseMessageFormat) {
                        throw ex;
                    }
                    // 如果格式未被强制执行，则默认继续处理原始消息
                    messageFormat = INVALID_MESSAGE_FORMAT;
                }
                //缓存当前消息的’消息格式组件‘
                messageFormatsPerLocale.put(locale, messageFormat);
            }
        }
        //消息解析对象为默认消息解析器，直接返回msg
        if (messageFormat == INVALID_MESSAGE_FORMAT) {
            return msg;
        }
        //使用messageFormat解析解析消息
        synchronized (messageFormat) {
            return messageFormat.format(resolveArguments(args, locale));
        }
    }

    //为给定的消息和区域设置创建一个MessageFormat。
    protected MessageFormat createMessageFormat(String msg, Locale locale) {
        return new MessageFormat((msg != null ? msg : ""), locale);
    }

    //子类可以覆盖，否则只是按原样返回给定的参数数组
    protected Object[] resolveArguments(Object[] args, Locale locale) {
        return args;
    }

}

DelegatingMessageSource消息源解析委派类

//第一部分：消息源解析委派类（用户未指定时，SpringContext默认使用当前类）
public class DelegatingMessageSource extends MessageSourceSupport implements HierarchicalMessageSource {
    //父消息解析源
    private MessageSource parentMessageSource;


    public void setParentMessageSource(MessageSource parent) {
        this.parentMessageSource = parent;
    }

    public MessageSource getParentMessageSource() {
        return this.parentMessageSource;
    }

    //解析消息，父消息解析源不为null时，则采用父消息源解析消息，否则有自身解析
    public String getMessage(String code, Object[] args, String defaultMessage, Locale locale) {
        if (this.parentMessageSource != null) { 
            return this.parentMessageSource.getMessage(code, args, defaultMessage, locale);
        }
        else {
            return renderDefaultMessage(defaultMessage, args, locale);
        }
    }
    //解析消息，父消息解析源不为null时，则采用父消息源解析消息，否则抛错
    public String getMessage(String code, Object[] args, Locale locale) throws NoSuchMessageException {
        if (this.parentMessageSource != null) {
            return this.parentMessageSource.getMessage(code, args, locale);
        }
        else {
            throw new NoSuchMessageException(code, locale);
        }
    }
    //解析消息，父消息解析源不为null时，则采用父消息源解析消息，否则有自身解析
    public String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException {
        if (this.parentMessageSource != null) {
            return this.parentMessageSource.getMessage(resolvable, locale);
        }
        else {
            if (resolvable.getDefaultMessage() != null) {
                return renderDefaultMessage(resolvable.getDefaultMessage(), resolvable.getArguments(), locale);
            }
            String[] codes = resolvable.getCodes();
            String code = (codes != null && codes.length > 0 ? codes[0] : null);
            throw new NoSuchMessageException(code, locale);
        }
    }

}

AbstractMessageSource抽象类

//第二部分：spring支持‘配置文件’的方式国际化资源 的 抽象类
public abstract class AbstractMessageSource extends MessageSourceSupport implements HierarchicalMessageSource {
    //父消息源
    private MessageSource parentMessageSource;

    //与区域设置无关的公共消息，消息代码为关键字
    // 
    //   
    //       
    //           classpath*:application.properties
    //       
    //   
    //
    private Properties commonMessages;

    //是否使用消息代码作为默认消息，而不是抛出NoSuchMessageException。 适用于开发和调试。
    private boolean useCodeAsDefaultMessage = false;


    public void setParentMessageSource(MessageSource parent) {
        this.parentMessageSource = parent;
    }

    public MessageSource getParentMessageSource() {
        return this.parentMessageSource;
    }

    /**
     * Specify locale-independent common messages, with the message code as key
     * and the full message String (may contain argument placeholders) as value.
     * 
May also link to an externally defined Properties object, e.g. defined
     * through a {@link org.springframework.beans.factory.config.PropertiesFactoryBean}.
     */
    public void setCommonMessages(Properties commonMessages) {
        this.commonMessages = commonMessages;
    }

    /**
     * Return a Properties object defining locale-independent common messages, if any.
     */
    protected Properties getCommonMessages() {
        return this.commonMessages;
    }

    //设置是否使用消息代码作为默认消息，而不是抛出NoSuchMessageException。 适用于开发和调试。
    //默认值为“false”。
    public void setUseCodeAsDefaultMessage(boolean useCodeAsDefaultMessage) {
        this.useCodeAsDefaultMessage = useCodeAsDefaultMessage;
    }
    protected boolean isUseCodeAsDefaultMessage() {
        return this.useCodeAsDefaultMessage;
    }


    public final String getMessage(String code, Object[] args, String defaultMessage, Locale locale) {
        String msg = getMessageInternal(code, args, locale);
        if (msg != null) {
            return msg;
        }
        if (defaultMessage == null) {
            String fallback = getDefaultMessage(code);
            if (fallback != null) {
                return fallback;
            }
        }
        return renderDefaultMessage(defaultMessage, args, locale);
    }

    public final String getMessage(String code, Object[] args, Locale locale) throws NoSuchMessageException {
        String msg = getMessageInternal(code, args, locale);
        if (msg != null) {
            return msg;
        }
        String fallback = getDefaultMessage(code);
        if (fallback != null) {
            return fallback;
        }
        throw new NoSuchMessageException(code, locale);
    }

    public final String getMessage(MessageSourceResolvable resolvable, Locale locale)
            throws NoSuchMessageException {

        String[] codes = resolvable.getCodes();
        if (codes == null) {
            codes = new String[0];
        }
        for (String code : codes) {
            String msg = getMessageInternal(code, resolvable.getArguments(), locale);
            if (msg != null) {
                return msg;
            }
        }
        String defaultMessage = resolvable.getDefaultMessage();
        if (defaultMessage != null) {
            return renderDefaultMessage(defaultMessage, resolvable.getArguments(), locale);
        }
        if (codes.length > 0) {
            String fallback = getDefaultMessage(codes[0]);
            if (fallback != null) {
                return fallback;
            }
        }
        throw new NoSuchMessageException(codes.length > 0 ? codes[codes.length - 1] : null, locale);
    }


    //将给定的代码和参数解析为给定的区域设置中的消息，如果没有找到返回{@code null}。 
    protected String getMessageInternal(String code, Object[] args, Locale locale) {
        if (code == null) {
            return null;
        }
        if (locale == null) {
            locale = Locale.getDefault();
        }
        Object[] argsToUse = args;

        if (!isAlwaysUseMessageFormat() && ObjectUtils.isEmpty(args)) {
            //解析不带参数数组的消息
            String message = resolveCodeWithoutArguments(code, locale);
            if (message != null) {
                return message;
            }
        }

        else {
            //解析参数数组
            argsToUse = resolveArguments(args, locale);
            //获取’消息格式化组件‘
            MessageFormat messageFormat = resolveCode(code, locale);
            if (messageFormat != null) {
                synchronized (messageFormat) {
                    return messageFormat.format(argsToUse);
                }
            }
        }

        // 检查指定消息代码的区域设置独立公共消息。获取配置文件中的消息主体
        Properties commonMessages = getCommonMessages();
        if (commonMessages != null) {
            String commonMessage = commonMessages.getProperty(code);
            if (commonMessage != null) {
                return formatMessage(commonMessage, args, locale);
            }
        }

        //未找到，则尝试使用父消息源解析消息（如果存在）
        return getMessageFromParent(code, argsToUse, locale);
    }

    //尝试从父MessageSource（如果有）检索给定的消息。
    protected String getMessageFromParent(String code, Object[] args, Locale locale) {
        MessageSource parent = getParentMessageSource();
        if (parent != null) {
            if (parent instanceof AbstractMessageSource) {
                // Call internal method to avoid getting the default code back
                // in case of "useCodeAsDefaultMessage" being activated.
                return ((AbstractMessageSource) parent).getMessageInternal(code, args, locale);
            }
            else {
                // Check parent MessageSource, returning null if not found there.
                return parent.getMessage(code, args, null, locale);
            }
        }
        // Not found in parent either.
        return null;
    }

    //返回默认消息。
    protected String getDefaultMessage(String code) {
        if (isUseCodeAsDefaultMessage()) { //返回给定代码作为默认消息。
            return code;
        }
        return null;
    }


    //通过给定的参数数组搜索，找到任何MessageSourceResolvable对象并解析它们。
    @Override
    protected Object[] resolveArguments(Object[] args, Locale locale) {
        if (args == null) {
            return new Object[0];
        }
        List resolvedArgs = new ArrayList(args.length);
        for (Object arg : args) {
            if (arg instanceof MessageSourceResolvable) {
                resolvedArgs.add(getMessage((MessageSourceResolvable) arg, locale));
            }
            else {
                resolvedArgs.add(arg);
            }
        }
        return resolvedArgs.toArray(new Object[resolvedArgs.size()]);
    }

    //解析不带参数的消息
    protected String resolveCodeWithoutArguments(String code, Locale locale) {
        MessageFormat messageFormat = resolveCode(code, locale);
        if (messageFormat != null) {
            synchronized (messageFormat) {
                return messageFormat.format(new Object[0]);
            }
        }
        return null;
    }

    //返回”消息格式化组件“（子类必须实现此方法来解决消息）
    protected abstract MessageFormat resolveCode(String code, Locale locale);

} 
  
StaticMessageSource
 
  

//实现类一：主要用于程序测试，它允许通过编程的方式提供国际化信息。
public class StaticMessageSource extends AbstractMessageSource {

    //从'code + locale'键映射到消息字符串
    private final Map messages = new HashMap();

    private final Map cachedMessageFormats = new HashMap();


    @Override
    protected String resolveCodeWithoutArguments(String code, Locale locale) {
        return this.messages.get(code + "_" + locale.toString());
    }

    @Override
    protected MessageFormat resolveCode(String code, Locale locale) {
        String key = code + "_" + locale.toString();
        //如果为手动关联的消息串，直接返回null
        String msg = this.messages.get(key);
        if (msg == null) {
            return null;
        }
        synchronized (this.cachedMessageFormats) {
            MessageFormat messageFormat = this.cachedMessageFormats.get(key);
            if (messageFormat == null) {
                //构建“消息格式组件”
                messageFormat = createMessageFormat(msg, locale);
                this.cachedMessageFormats.put(key, messageFormat);
            }
            return messageFormat;
        }
    }

    //将给定的消息与给定的代码相关联。
    public void addMessage(String code, Locale locale, String msg) {
        Assert.notNull(code, "Code must not be null");
        Assert.notNull(locale, "Locale must not be null");
        Assert.notNull(msg, "Message must not be null");
        this.messages.put(code + "_" + locale.toString(), msg);
        if (logger.isDebugEnabled()) {
            logger.debug("Added message [" + msg + "] for code [" + code + "] and Locale [" + locale + "]");
        }
    }

    //批量将给定的消息与给定的代码相关联。
    public void addMessages(Map messages, Locale locale) {
        Assert.notNull(messages, "Messages Map must not be null");
        for (Map.Entry entry : messages.entrySet()) {
            addMessage(entry.getKey(), locale, entry.getValue());
        }
    }


    @Override
    public String toString() {
        return getClass().getName() + ": " + this.messages;
    }

}
 
  
ResourceBundleMessageSource
 
  
//实现类二：该实现类允许用户通过beanName指定一个资源名（包括类路径的全限定资源名），或通过beanNames指定一组资源名。
//使用方式：
//  
//   
//       
//       com/baobaotao/i18n/fmt_resource  
//       
//    
//  
public class ResourceBundleMessageSource extends AbstractMessageSource implements BeanClassLoaderAware {
    //资源文件列表（包括类路径的全限定资源名）
    private String[] basenames = new String[0];
    //用于解析资源束文件的默认字符集。
    private String defaultEncoding;
    //是否使用系统默认的编码
    private boolean fallbackToSystemLocale = true;
    //缓存时间
    private long cacheMillis = -1;
    //加载绑定资源文件的类加载器
    private ClassLoader bundleClassLoader;

    private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

    //缓存code和区域所对应 资源包ResourceBundles。
    private final Map> cachedResourceBundles =
            new HashMap>();

    //缓存ResourceBundle和code及local所对应的MessageFormat
    private final Map>> cachedBundleMessageFormats =
            new HashMap>>();

    //设置资源文件
    public void setBasename(String basename) {
        setBasenames(basename);
    }
    //批量设置资源文件
    public void setBasenames(String... basenames) {
        if (basenames != null) {
            this.basenames = new String[basenames.length];
            for (int i = 0; i < basenames.length; i++) {
                String basename = basenames[i];
                Assert.hasText(basename, "Basename must not be empty");
                this.basenames[i] = basename.trim();
            }
        }
        else {
            this.basenames = new String[0];
        }
    }

    //设置用于解析绑定的资源文件的默认字符集。
    public void setDefaultEncoding(String defaultEncoding) {
        this.defaultEncoding = defaultEncoding;
    }

    //设置是否返回到系统区域设置，如果没有找到特定语言环境的文件。 
    // 默认为“true”; 如果这是关闭的，唯一的后备将是默认文件（例如，basename“messages”的“messages.properties”）。
    public void setFallbackToSystemLocale(boolean fallbackToSystemLocale) {
        this.fallbackToSystemLocale = fallbackToSystemLocale;
    }


    //设置缓存加载的绑定的资源文件的秒数。
    public void setCacheSeconds(int cacheSeconds) {
        this.cacheMillis = (cacheSeconds * 1000);
    }


    //设置记载绑定资源文件的类加载器
    public void setBundleClassLoader(ClassLoader classLoader) {
        this.bundleClassLoader = classLoader;
    }

    protected ClassLoader getBundleClassLoader() {
        return (this.bundleClassLoader != null ? this.bundleClassLoader : this.beanClassLoader);
    }

    //设置bean类加载器
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.beanClassLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader());
    }


    /**
     * 将给定的消息代码解析为已注册资源包中的key，按原样返回捆绑包中的值（不使用MessageFormat解析）。
     */
    @Override
    protected String resolveCodeWithoutArguments(String code, Locale locale) {
        String result = null;
        for (int i = 0; result == null && i < this.basenames.length; i++) {
            ResourceBundle bundle = getResourceBundle(this.basenames[i], locale);
            if (bundle != null) {
                result = getStringOrNull(bundle, code);
            }
        }
        return result;
    }

    /**
     * 将给定的消息代码解析为注册资源包中的key，每个消息代码使用缓存的MessageFormat实例。
     */
    @Override
    protected MessageFormat resolveCode(String code, Locale locale) {
        MessageFormat messageFormat = null;
        for (int i = 0; messageFormat == null && i < this.basenames.length; i++) {
            ResourceBundle bundle = getResourceBundle(this.basenames[i], locale);
            if (bundle != null) {
                messageFormat = getMessageFormat(bundle, code, locale);
            }
        }
        return messageFormat;
    }


    //为给定的basename和代码返回一个ResourceBundle，从缓存中提取已生成的MessageFormats。
    protected ResourceBundle getResourceBundle(String basename, Locale locale) {
        if (this.cacheMillis >= 0) { 
            // 新建ResourceBundle.getBundle调用，以使ResourceBundle执行其本地缓存，而不必花费更广泛的查找步骤。
            return doGetBundle(basename, locale);
        }
        else {
            // 永久缓存：在重复的getBundle调用中优先使用语言环境缓存。
            synchronized (this.cachedResourceBundles) {
                //先获取缓存
                Map localeMap = this.cachedResourceBundles.get(basename);
                if (localeMap != null) {
                    ResourceBundle bundle = localeMap.get(locale);
                    if (bundle != null) {
                        return bundle;
                    }
                }
                //没找到缓存
                try {
                    ResourceBundle bundle = doGetBundle(basename, locale);
                    if (localeMap == null) {
                        localeMap = new HashMap();
                        this.cachedResourceBundles.put(basename, localeMap);
                    }
                    //放入缓存
                    localeMap.put(locale, bundle);
                    return bundle;
                }
                catch (MissingResourceException ex) {
                    if (logger.isWarnEnabled()) {
                        logger.warn("ResourceBundle [" + basename + "] not found for MessageSource: " + ex.getMessage());
                    }
                    // Assume bundle not found
                    // -> do NOT throw the exception to allow for checking parent message source.
                    return null;
                }
            }
        }
    }

    //获取给定basename和locale设置的资源包。
    protected ResourceBundle doGetBundle(String basename, Locale locale) throws MissingResourceException {
        if ((this.defaultEncoding != null && !"ISO-8859-1".equals(this.defaultEncoding)) ||
                !this.fallbackToSystemLocale || this.cacheMillis >= 0) {
            //jdk版本不能小于16
            if (JdkVersion.getMajorJavaVersion() < JdkVersion.JAVA_16) {
                throw new IllegalStateException("Cannot use 'defaultEncoding', 'fallbackToSystemLocale' and " +
                        "'cacheSeconds' on the standard ResourceBundleMessageSource when running on Java 5. " +
                        "Consider using ReloadableResourceBundleMessageSource instead.");
            }
            return new ControlBasedResourceBundleFactory().getBundle(basename, locale);
        }
        else {
            // Good old standard call...
            return ResourceBundle.getBundle(basename, locale, getBundleClassLoader());
        }
    }

    //为给定的包和代码返回一个MessageFormat，从缓存中提取已生成的MessageFormats。
    protected MessageFormat getMessageFormat(ResourceBundle bundle, String code, Locale locale)
            throws MissingResourceException {

        synchronized (this.cachedBundleMessageFormats) {
            //先走缓存
            Map> codeMap = this.cachedBundleMessageFormats.get(bundle);
            Map localeMap = null;
            if (codeMap != null) {
                localeMap = codeMap.get(code);
                if (localeMap != null) {
                    MessageFormat result = localeMap.get(locale);
                    if (result != null) {
                        return result;
                    }
                }
            }
            //缓存为空的话，执行下面步骤
            //获取资源包中指定key所对应的值
            String msg = getStringOrNull(bundle, code);
            if (msg != null) {
                //放入缓存
                if (codeMap == null) {
                    codeMap = new HashMap>();
                    this.cachedBundleMessageFormats.put(bundle, codeMap);
                }
                if (localeMap == null) {
                    localeMap = new HashMap();
                    codeMap.put(code, localeMap);
                }
                MessageFormat result = createMessageFormat(msg, locale);
                localeMap.put(locale, result);
                return result;
            }

            return null;
        }
    }
    //获取资源包中指定key所对应的值
    private String getStringOrNull(ResourceBundle bundle, String key) {
        try {
            return bundle.getString(key);
        }
        catch (MissingResourceException ex) {
            // Assume key not found
            // -> do NOT throw the exception to allow for checking parent message source.
            return null;
        }
    }

    /**
     * Show the configuration of this MessageSource.
     */
    @Override
    public String toString() {
        return getClass().getName() + ": basenames=[" +
                StringUtils.arrayToCommaDelimitedString(this.basenames) + "]";
    }


    /**
     * Factory indirection for runtime isolation of the optional dependencv on
     * Java 6's Control class.
     * @see ResourceBundle#getBundle(String, java.util.Locale, ClassLoader, java.util.ResourceBundle.Control)
     * @see MessageSourceControl
     */
    private class ControlBasedResourceBundleFactory {

        public ResourceBundle getBundle(String basename, Locale locale) {
            return ResourceBundle.getBundle(basename, locale, getBundleClassLoader(), new MessageSourceControl());
        }
    }


    /**
     * Custom implementation of Java 6's {@code ResourceBundle.Control},
     * adding support for custom file encodings, deactivating the fallback to the
     * system locale and activating ResourceBundle's native cache, if desired.
     */
    private class MessageSourceControl extends ResourceBundle.Control {

        @Override
        public ResourceBundle newBundle(String baseName, Locale locale, String format, ClassLoader loader, boolean reload)
                throws IllegalAccessException, InstantiationException, IOException {
            if (format.equals("java.properties")) {
                //按不同区域获取所对应的不同资源文件名称
                String bundleName = toBundleName(baseName, locale);
                final String resourceName = toResourceName(bundleName, "properties");
                final ClassLoader classLoader = loader;
                final boolean reloadFlag = reload;
                InputStream stream;
                try {
                    stream = AccessController.doPrivileged(
                            new PrivilegedExceptionAction() {
                                public InputStream run() throws IOException {
                                    InputStream is = null;
                                    if (reloadFlag) {
                                        URL url = classLoader.getResource(resourceName);
                                        if (url != null) {
                                            URLConnection connection = url.openConnection();
                                            if (connection != null) {
                                                connection.setUseCaches(false);
                                                is = connection.getInputStream();
                                            }
                                        }
                                    }
                                    else {
                                        is = classLoader.getResourceAsStream(resourceName);
                                    }
                                    return is;
                                }
                            });
                }
                catch (PrivilegedActionException ex) {
                    throw (IOException) ex.getException();
                }
                if (stream != null) {
                    try {
                        return (defaultEncoding != null ?
                                new PropertyResourceBundle(new InputStreamReader(stream, defaultEncoding)) :
                                new PropertyResourceBundle(stream));
                    }
                    finally {
                        stream.close();
                    }
                }
                else {
                    return null;
                }
            }
            else {
                return super.newBundle(baseName, locale, format, loader, reload);
            }
        }

        @Override
        public Locale getFallbackLocale(String baseName, Locale locale) {
            return (fallbackToSystemLocale ? super.getFallbackLocale(baseName, locale) : null);
        }

        @Override
        public long getTimeToLive(String baseName, Locale locale) {
            return (cacheMillis >= 0 ? cacheMillis : super.getTimeToLive(baseName, locale));
        }

        @Override
        public boolean needsReload(String baseName, Locale locale, String format, ClassLoader loader, ResourceBundle bundle, long loadTime) {
            if (super.needsReload(baseName, locale, format, loader, bundle, loadTime)) {
                cachedBundleMessageFormats.remove(bundle);
                return true;
            }
            else {
                return false;
            }
        }
    }

}
 
  
ReloadableResourceBundleMessageSource
 
  

//实现类三：该实现类允许用户通过beanName指定一个资源名（包括类路径的全限定资源名），或通过beanNames指定一组资源名。
//使用方式：
//  
//   
//       
//       com/baobaotao/i18n/fmt_resource  
//       
//    
//    
//     
//  
public class ReloadableResourceBundleMessageSource extends AbstractMessageSource
        implements ResourceLoaderAware {

    private static final String PROPERTIES_SUFFIX = ".properties";

    private static final String XML_SUFFIX = ".xml";

    //资源文件包名
    private String[] basenames = new String[0];
    //默认编码方式
    private String defaultEncoding;
    //不同文件设置不同的编码方式
    private Properties fileEncodings;
    //使用系统区域设置
    private boolean fallbackToSystemLocale = true;
    //缓存时间
    private long cacheMillis = -1;

    private PropertiesPersister propertiesPersister = new DefaultPropertiesPersister();

    private ResourceLoader resourceLoader = new DefaultResourceLoader();

    /** 文件名-区域 所对应的配置文件名 */
    private final Map>> cachedFilenames =
            new HashMap>>();

    /** 缓存来保存每个文件名已经加载的属性 */
    private final Map cachedProperties = new HashMap();

    /** 缓存以保存每个区域的合并加载属性*/
    private final Map cachedMergedProperties = new HashMap();



    public void setBasename(String basename) {
        setBasenames(basename);
    }
    public void setBasenames(String... basenames) {
        if (basenames != null) {
            this.basenames = new String[basenames.length];
            for (int i = 0; i < basenames.length; i++) {
                String basename = basenames[i];
                Assert.hasText(basename, "Basename must not be empty");
                this.basenames[i] = basename.trim();
            }
        }
        else {
            this.basenames = new String[0];
        }
    }


    public void setDefaultEncoding(String defaultEncoding) {
        this.defaultEncoding = defaultEncoding;
    }

    public void setFileEncodings(Properties fileEncodings) {
        this.fileEncodings = fileEncodings;
    }

    public void setFallbackToSystemLocale(boolean fallbackToSystemLocale) {
        this.fallbackToSystemLocale = fallbackToSystemLocale;
    }
    //过期时间设置
    public void setCacheSeconds(int cacheSeconds) {
        this.cacheMillis = (cacheSeconds * 1000);
    }

    //设置PropertiesPersister用于解析属性文件。
    public void setPropertiesPersister(PropertiesPersister propertiesPersister) {
        this.propertiesPersister =
                (propertiesPersister != null ? propertiesPersister : new DefaultPropertiesPersister());
    }

    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = (resourceLoader != null ? resourceLoader : new DefaultResourceLoader());
    }


    /**
     * 将给定的消息代码解析为检索到的包文件中的key，按原样返回包中找到的值（不使用MessageFormat解析）。
     */
    @Override
    protected String resolveCodeWithoutArguments(String code, Locale locale) {
        if (this.cacheMillis < 0) {
            PropertiesHolder propHolder = getMergedProperties(locale);
            String result = propHolder.getProperty(code);
            if (result != null) {
                return result;
            }
        }
        else {
            for (String basename : this.basenames) {
                List filenames = calculateAllFilenames(basename, locale);
                for (String filename : filenames) {
                    PropertiesHolder propHolder = getProperties(filename);
                    String result = propHolder.getProperty(code);
                    if (result != null) {
                        return result;
                    }
                }
            }
        }
        return null;
    }

    /**
     * 将给定的消息代码解析为检索到的包文件中的key，每个消息代码使用缓存的MessageFormat实例。
     */
    @Override
    protected MessageFormat resolveCode(String code, Locale locale) {
        if (this.cacheMillis < 0) { 
            PropertiesHolder propHolder = getMergedProperties(locale);
            MessageFormat result = propHolder.getMessageFormat(code, locale);
            if (result != null) {
                return result;
            }
        }
        else {
            //遍历资源包，生成key所对应的messageFormat
            for (String basename : this.basenames) {
                List filenames = calculateAllFilenames(basename, locale);
                for (String filename : filenames) {
                    PropertiesHolder propHolder = getProperties(filename);
                    MessageFormat result = propHolder.getMessageFormat(code, locale);
                    if (result != null) {
                        return result;
                    }
                }
            }
        }
        return null;
    }


    /**
     * 获取locale所对应的持有properties对象
     */
    protected PropertiesHolder getMergedProperties(Locale locale) {
        synchronized (this.cachedMergedProperties) {
            //先走缓存
            PropertiesHolder mergedHolder = this.cachedMergedProperties.get(locale);
            if (mergedHolder != null) {
                return mergedHolder;
            }
            //创建一个新的properties对象
            Properties mergedProps = new Properties();
            //创建一个的持有properties的对象
            mergedHolder = new PropertiesHolder(mergedProps, -1);
            for (int i = this.basenames.length - 1; i >= 0; i--) {//遍历资源包名列表
                //获取该区域该资源包名所对应的资源文件列表
                List filenames = calculateAllFilenames(this.basenames[i], locale);
                for (int j = filenames.size() - 1; j >= 0; j--) {
                    String filename = (String) filenames.get(j);
                    PropertiesHolder propHolder = getProperties(filename);
                    if (propHolder.getProperties() != null) {
                        mergedProps.putAll(propHolder.getProperties());
                    }
                }
            }
            this.cachedMergedProperties.put(locale, mergedHolder);
            return mergedHolder;
        }
    }

    /**
     * 计算给定的捆绑包基础名称和区域设置的所有文件名。 将计算给定区域设置的文件名，系统区域设置（如果适用）和默认文件。
     * @param basename the basename of the bundle
     * @param locale the locale
     * @return the List of filenames to check
     * @see #setFallbackToSystemLocale
     * @see #calculateFilenamesForLocale
     */
    protected List calculateAllFilenames(String basename, Locale locale) {
        synchronized (this.cachedFilenames) {
            Map> localeMap = this.cachedFilenames.get(basename);
            if (localeMap != null) {
                List filenames = localeMap.get(locale);
                if (filenames != null) {
                    return filenames;
                }
            }
            List filenames = new ArrayList(7);
            filenames.addAll(calculateFilenamesForLocale(basename, locale));
            if (this.fallbackToSystemLocale && !locale.equals(Locale.getDefault())) {
                List fallbackFilenames = calculateFilenamesForLocale(basename, Locale.getDefault());
                for (String fallbackFilename : fallbackFilenames) {
                    if (!filenames.contains(fallbackFilename)) {
                        // Entry for fallback locale that isn't already in filenames list.
                        filenames.add(fallbackFilename);
                    }
                }
            }
            filenames.add(basename);
            if (localeMap != null) {
                localeMap.put(locale, filenames);
            }
            else {
                localeMap = new HashMap>();
                localeMap.put(locale, filenames);
                this.cachedFilenames.put(basename, localeMap);
            }
            return filenames;
        }
    }

    /**
     * Calculate the filenames for the given bundle basename and Locale,
     * appending language code, country code, and variant code.
     * E.g.: basename "messages", Locale "de_AT_oo" -> "messages_de_AT_OO",
     * "messages_de_AT", "messages_de".
     * 
Follows the rules defined by {@link java.util.Locale#toString()}.
     * @param basename the basename of the bundle
     * @param locale the locale
     * @return the List of filenames to check
     */
    protected List calculateFilenamesForLocale(String basename, Locale locale) {
        List result = new ArrayList(3);
        String language = locale.getLanguage();
        String country = locale.getCountry();
        String variant = locale.getVariant();
        StringBuilder temp = new StringBuilder(basename);

        temp.append('_');
        if (language.length() > 0) {
            temp.append(language);
            result.add(0, temp.toString());
        }

        temp.append('_');
        if (country.length() > 0) {
            temp.append(country);
            result.add(0, temp.toString());
        }

        if (variant.length() > 0 && (language.length() > 0 || country.length() > 0)) {
            temp.append('_').append(variant);
            result.add(0, temp.toString());
        }

        return result;
    }


    //从缓存或新加载中获取给定文件名的PropertiesHolder。
    protected PropertiesHolder getProperties(String filename) {
        synchronized (this.cachedProperties) {
            PropertiesHolder propHolder = this.cachedProperties.get(filename);
            //判断是否需要刷新
            if (propHolder != null &&
                    (propHolder.getRefreshTimestamp() < 0 ||
                     propHolder.getRefreshTimestamp() > System.currentTimeMillis() - this.cacheMillis)) {
                // up to date
                return propHolder;
            }
            return refreshProperties(filename, propHolder);
        }
    }

    //刷新给定包文件名的PropertiesHolder。 
    protected PropertiesHolder refreshProperties(String filename, PropertiesHolder propHolder) {
        //记录刷新时间
        long refreshTimestamp = (this.cacheMillis < 0 ? -1 : System.currentTimeMillis());
        //加载资源文件所对应的resource对象
        Resource resource = this.resourceLoader.getResource(filename + PROPERTIES_SUFFIX);
        if (!resource.exists()) { //如果resource不存在，则加载对应的xml文件
            resource = this.resourceLoader.getResource(filename + XML_SUFFIX);
        }

        if (resource.exists()) {
            long fileTimestamp = -1;
            if (this.cacheMillis >= 0) {
                // 如果设置了缓存时间，文件的最后修改的时间戳将被读取。
                try {
                    //最近一次操作时间
                    fileTimestamp = resource.lastModified();
                    if (propHolder != null && propHolder.getFileTimestamp() == fileTimestamp) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Re-caching properties for filename [" + filename + "] - file hasn't been modified");
                        }
                        //设置刷新时间
                        propHolder.setRefreshTimestamp(refreshTimestamp);
                        return propHolder;
                    }
                }
                catch (IOException ex) {
                    // Probably a class path resource: cache it forever.
                    if (logger.isDebugEnabled()) {
                        logger.debug(
                                resource + " could not be resolved in the file system - assuming that is hasn't changed", ex);
                    }
                    fileTimestamp = -1;
                }
            }
            try {
                //从给定的resource中加载properties
                Properties props = loadProperties(resource, filename);
                propHolder = new PropertiesHolder(props, fileTimestamp);
            }
            catch (IOException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Could not parse properties file [" + resource.getFilename() + "]", ex);
                }
                // 加载报错，创建一个空的PropertiesHolder对象
                propHolder = new PropertiesHolder();
            }
        }

        else {
            // Resource 不存在
            if (logger.isDebugEnabled()) {
                logger.debug("No properties file found for [" + filename + "] - neither plain properties nor XML");
            }
            // 创建一个空的PropertiesHolder对象
            propHolder = new PropertiesHolder();
        }
        //设置刷新时间
        propHolder.setRefreshTimestamp(refreshTimestamp);
        //放入缓存
        this.cachedProperties.put(filename, propHolder);
        return propHolder;
    }

    /**
     * 解析给定的resource资源中返回对应properties对象
     * @param resource the resource to load from
     * @param filename the original bundle filename (basename + Locale)
     * @return the populated Properties instance
     * @throws IOException if properties loading failed
     */
    protected Properties loadProperties(Resource resource, String filename) throws IOException {
        InputStream is = resource.getInputStream();
        Properties props = new Properties();
        try {
            //xml资源文件
            if (resource.getFilename().endsWith(XML_SUFFIX)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Loading properties [" + resource.getFilename() + "]");
                }
                //解析xml文件
                this.propertiesPersister.loadFromXml(props, is);
            }
            else {
                //优先取filename所对应编码设置，没有则取默认设置
                String encoding = null;
                if (this.fileEncodings != null) {
                    encoding = this.fileEncodings.getProperty(filename);
                }
                if (encoding == null) {
                    encoding = this.defaultEncoding;
                }
                if (encoding != null) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Loading properties [" + resource.getFilename() + "] with encoding '" + encoding + "'");
                    }
                    this.propertiesPersister.load(props, new InputStreamReader(is, encoding));
                }
                else {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Loading properties [" + resource.getFilename() + "]");
                    }
                    this.propertiesPersister.load(props, is);
                }
            }
            return props;
        }
        finally {
            is.close();
        }
    }


    /**
     * 清除所有资源包对应的properties缓存。
     */
    public void clearCache() {
        logger.debug("Clearing entire resource bundle cache");
        synchronized (this.cachedProperties) {
            this.cachedProperties.clear();
        }
        synchronized (this.cachedMergedProperties) {
            this.cachedMergedProperties.clear();
        }
    }

    /**
     * 清除此MessageSource及其所有父资源的缓存。
     * @see #clearCache
     */
    public void clearCacheIncludingAncestors() {
        clearCache();
        if (getParentMessageSource() instanceof ReloadableResourceBundleMessageSource) {
            ((ReloadableResourceBundleMessageSource) getParentMessageSource()).clearCacheIncludingAncestors();
        }
    }


    @Override
    public String toString() {
        return getClass().getName() + ": basenames=[" + StringUtils.arrayToCommaDelimitedString(this.basenames) + "]";
    }


    /**
     * PropertiesHolder for caching.
     * 存储源文件的最后修改的时间戳以进行有效的更改检测，以及上次刷新尝试的时间戳（每次缓存条目重新验证时更新）。
     */
    protected class PropertiesHolder {
        //所持有properties对象
        private Properties properties;
        //源文件的最后修改的时间戳
        private long fileTimestamp = -1;
        //刷新时间
        private long refreshTimestamp = -1;

        /** 缓存：每个code已经生成的各区域所对应MessageFormats */
        private final Map> cachedMessageFormats =
                new HashMap>();

        public PropertiesHolder(Properties properties, long fileTimestamp) {
            this.properties = properties;
            this.fileTimestamp = fileTimestamp;
        }

        public PropertiesHolder() {
        }

        public Properties getProperties() {
            return properties;
        }

        public long getFileTimestamp() {
            return fileTimestamp;
        }

        public void setRefreshTimestamp(long refreshTimestamp) {
            this.refreshTimestamp = refreshTimestamp;
        }

        public long getRefreshTimestamp() {
            return refreshTimestamp;
        }

        public String getProperty(String code) {
            if (this.properties == null) {
                return null;
            }
            return this.properties.getProperty(code);
        }

        public MessageFormat getMessageFormat(String code, Locale locale) {
            if (this.properties == null) {
                return null;
            }
            synchronized (this.cachedMessageFormats) {
                //先尝试走缓存
                Map localeMap = this.cachedMessageFormats.get(code);
                if (localeMap != null) {
                    MessageFormat result = localeMap.get(locale);
                    if (result != null) {
                        return result;
                    }
                }
                //缓存没有，则properties中code所对应的值
                String msg = this.properties.getProperty(code);
                if (msg != null) {
                    if (localeMap == null) {
                        localeMap = new HashMap();
                        this.cachedMessageFormats.put(code, localeMap);
                    }
                    //构建 MessageFormat 放入缓存
                    MessageFormat result = createMessageFormat(msg, locale);
                    localeMap.put(locale, result);
                    return result;
                }
                return null;
            }
        }
    }

}

 
  
MessageFormat 消息格式化组件
 
  
这个类的功能比较强大，主要就是将消息串、参数数组格式化成字符串。例如：“{0}去上学”和参数“小明”，格式化成：“小明去上学”！
 
  
//’消息格式化组件‘
public class MessageFormat extends Format {

    private static final long serialVersionUID = 6479157306784022952L;


    private int maxOffset = -1;

    //构造方法
    public MessageFormat(String pattern) {
        this.locale = Locale.getDefault(Locale.Category.FORMAT);
        applyPattern(pattern);
    }

    //构造方法
    public MessageFormat(String pattern, Locale locale) {
        this.locale = locale;
        applyPattern(pattern);
    }

    //消息区域设置
    public void setLocale(Locale locale) {
        this.locale = locale;
    }

    //获取消息区域
    public Locale getLocale() {
        return locale;
    }

    //格式化
    public final String format (Object obj) {
        return format(obj, new StringBuffer(), new FieldPosition(0)).toString();
    }

    public final StringBuffer format(Object arguments, StringBuffer result,
                                     FieldPosition pos)
    {
        return subformat((Object[]) arguments, result, pos, null);
    }

    //======省略很多代码^_^========／

}
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(jdk8源码阅读)

        

            

                
    
                    
  • SpringBoot3与SpringBoot2的区别
                        bjzhang75
springboot
                        
    文章目录1、JDK环境2、SpringFramework版本3、主要变化和新特性3.1配置变化3.2GraalVM3.3安全性改进3.4性能优化3.4.1启动时间3.4.2内存使用3.5改进的依赖管理3.6全新启动器3.7Kotlin支持SpringBoot3与SpringBoot2的区别1、JDK环境SpringBoot3最低要求JDK17SpringBoot2最低要求JDK82、SpringF
    
                    
    • 
                    
  • source insight4.0中文乱码解决方法
                        鹿屿二向箔
c语言stm32keilmdk
                        
    Sourceinsight是强大、顺手的代码编辑器，它几乎支持所有的语言，包括：C，C++，C#，HTML等等，能够自动创建并维护它自己高性能的符号数据库，包括函数、全局变量、结构、类和工程源文件里定义的其它类型的符号，对于大工程的源码阅读非常方便。但是因为是国外软件，对中文支持不是很好，很多电脑安装使用都会出现注释乱码问题，很让人抓狂。网上很多人遇到类似的问题，也有很多解决方式，也有很多“终极解
    
                    
    • 
                    
  • netty4源码阅读与分析---netty线程模型
                        红尘之一骑
javaNIOnetty源码阅读与分析
                        
    本文主要说下我自己对netty线程模型的理解，以及这样的线程模型的好处。通俗的来讲，netty的线程模型描述的就是老板和员工的故事。老板(通常情况下是一个老板)负责接活，与客户沟通，协调(netty的accept),谈成后(通道建立)，他需要从员工中选出一位员工来负责处理后续具体的事宜(worker线程，这里我们有16位员工，编号1-16)，员工做事时按照任务的先后顺序进行处理，这样可以避免错乱，
    
                    
    • 
                    
  • 登录校验实现——Jwt、Filter/Interceptor
                        应起忆
javaspring
                        
    Jwt令牌生成引入依赖，JDK8之后的版本需要引入JAXBjavax.xml.bindjaxb-api2.3.1org.glassfish.jaxbjaxb-runtime2.3.1io.jsonwebtokenjjwt0.9.1写JwtUtilsimportio.jsonwebtoken.Claims;importio.jsonwebtoken.Jwts;importio.jsonwebtoke
    
                    
    • 
                    
  • clickhouse-v24.1-离线部署
                        Wonderful呀
数据库clickhouse数据库运维linux
                        
    部署版本数据库版本：24.1.1.2048jdk版本：jdk84个文件（三个ck的包）：OpenJDK8U-jdk_x64_linux_hotspot_8u382b05.tarclickhouse-client-24.1.1.2048.x86_64.rpmclickhouse-common-static-24.1.1.2048.x86_64.rpmclickhouse-server-24.1.1.
    
                    
    • 
                    
  • Java 实现自定义注解
                        kkkkatoq
java实现自定义注解java开发语言
                        
    一、@interface关键字我们想定义一个自己的注解需要使用@interface关键字来定义。如定义一个叫MyAnnotation的注解：public@interfaceMyAnnotation{}二、元注解光加上@interface关键字还不够，我们还需要了解5大元注解@Retention@Target@Documented@Inherited（JDK8引入）@Repeatable（JDK8引
    
                    
    • 
                    
  • HBase 源码阅读（一）
                        Such Devotion
hbase数据库大数据
                        
    1.HMastermain方法在上文中MacosM1IDEA本地调试HBase2.2.2，我们使用HMaster的主函数使用"start"作为入参，启动了HMaster进程这里我们再深入了解下HMaster的运行机理publicstaticvoidmain(String[]args){LOG.info("STARTINGservice"+HMaster.class.getSimpleName())
    
                    
    • 
                    
  • HBase 源码阅读（四）HBase 关于LSM Tree的实现- MemStore
                        Such Devotion
hbaselsm-tree数据库
                        
    4.MemStore接口Memstore的函数不能并行的被调用。调用者需要持有读写锁，这个的实现在HStore中我们放弃对MemStore中的诸多函数进行查看直接看MemStore的实现类AbstractMemStoreCompactingMemStoreDefaultMemStore4.1三个实现类的使用场景1.AbstractMemStore角色:基础抽象类作用:AbstractMemStor
    
                    
    • 
                    
  • jdk8新特性
                        五_六柒

                        
    默认方法。一个在接口里面有了一个实现的方法。只需在方法名前面加个default关键字即可实现默认方法。lambda表达式。Lambda允许把函数作为一个方法的参数传递进方法中。它实际上是个匿名函数。方法引用。java8允许使用::关键字来传递方法或者构造函数引用。函数式接口。一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。可以使用lambda表达式作为接口中唯一一个抽象方法的具体实现。@
    
                    
    • 
                    
  • 函数式编程-Stream流
                        码农OvO
开发语言java
                        
    函数式编程-Stream流1.概述1.1好处大数量下处理集合效率高代码可读性高消灭嵌套1.2函数式编程思想1.2.1概念面向对象思想需要关注用什么对象完成什么事情。而函数式编程思想就类似于我们数学中的函数。它主要关注的是对数据进行了什么操作。1.2.2优点代码简洁接近自然语言，易于理解易于"并发编程"2.Lambda表达式2.1概述Lambda是Jdk8中的一个语法糖。它可以对某些匿名内部类的写法
    
                    
    • 
                    
  • Nginx源码阅读笔记-内存池的设计
                        weixin_33701564
运维python数据结构与算法
                        
    2019独角兽企业重金招聘Python工程师标准>>>nginx的内存池设计的比较简单了，一个内存池中分为两个部分：超过max大小的内存分配，走大块内存分配，这部分内存管理由ngx_pool_large_t结构体负责。否则就是在ngx_pool_t遍历符合要求的ngx_pool_t结构体，找到符合要求大小的pool直接返回，否则就申请一块新的内存pool。nginx中所有请求都单独对应一个内存池，
    
                    
    • 
                    
  • Mac 安装Hadoop教程（HomeBrew安装）
                        追光天使
macoshadoop大数据
                        
    1.引言本教程旨在介绍在Mac电脑上安装Hadoop，便于编程开发人员对大数据技术的熟悉和掌握。2.前提条件2.1安装JDK想要在你的Mac电脑上安装Hadoop，你必须首先安装JDK。具体安装步骤这里就不详细描述了。你可参考Mac安装JDK8。2.2配置ssh环境在Mac下配置ssh环境，防止后面启动hadoop时出现Connectionrefused连接被拒绝的错误。sshlocalhost执
    
                    
    • 
                    
  • 面试：说一下HashMap的底层实现原理，我懵了
                        一只程序猿哟

                        
    哈希表（hashtable）也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，而HashMap的实现原理也常常出现在各类的面试题中，重要性可见一斑。本文会对java集合框架中的对应实现HashMap的实现原理进行讲解，然后会对JDK7的HashMap源码进行分析（JDK8会有所不同，需要了解的可自行阅读JDK8的
    
                    
    • 
                    
  • HBase 源码阅读（二）
                        Such Devotion
hbase数据库大数据
                        
    衔接在上一篇文章中，HMasterCommandLine类中在startMaster();方法中//这里除了启动HMaster之外，还启动一个HRegionServerLocalHBaseClustercluster=newLocalHBaseCluster(conf,mastersCount,regionServersCount,LocalHMaster.class,HRegionServer.
    
                    
    • 
                    
  • 聊聊自学数据结构与算法
                        莫天幽
数据结构算法
                        
    聊聊自学数据结构与算法大家好，我是莫幽天很高兴你能够阅读到我的文章。说道自学算法，不知道你是带着一个什么样的心情来学习，我呢是觉得基础太重要了。所以又来尝试深入的学习数据结构与算法。为什么这么说呢，我是一名Java开发的程序猿，现在jdk已经出到18了（时间北京时间：2021-07-28），但是呢开发一般还在用jdk8。一般的Java程序猿也就了解个jdk8的特性。上层变化的太快，想记忆需要长期持
    
                    
    • 
                    
  • URP Shader 源码阅读 （一） Simple Lit
                        [email protected]
游戏开发unity
                        
    URP版本16.0.6打开SimpleLit.shader文件；SubShaderTags：Tags{"RenderType"="Opaque""RenderPipeline"="UniversalPipeline"//该SubShader是给UniversalPipeline使用的"UniversalMaterialType"="SimpleLit"//延迟渲染使用，标识光照模式"IgnoreP
    
                    
    • 
                    
  • JDK8重复注解与类型注解
                        星空椰
JAVAJDK新特性java开发语言
                        
    目录一、重复注解的使用二、类型注解的使用一、重复注解的使用JDK8引入了重复注解的概念，允许在同一个地方多次使用同一个注解。在JDK8中使用@Repeatable注解定义重复注解。重复注解的使用步骤：1.定义重复的注解容器注解@Retention(RetentionPolicy.RUNTIME)@interfaceMyTests{MyTest[]value();}2.定义一个可以重复的注解@Ret
    
                    
    • 
                    
  • JVM-3-JVM调优
                        宠辱不惊的咸鱼

                        
    问题JDK8默认GC策略PSYoung+ParOld什么时候开始YoungGCEden不够分配时什么时候开始FullGCOld区可用容量不足历次平均晋升担保失败CMS会有什么问题并发失败，并发阶段直接爆掉怎么规避：增大空闲比例G1什么时候会进入FullGC标记期跪掉；FullGC时会采用Serial，所以还是比较可怕的怎么规避：减小开始标记的内存占用阈值InitiatingHeapOccupanc
    
                    
    • 
                    
  • JDK8优化JVM总结
                        闫小甲
jvm
                        
    JDK8优化JVM总结默认垃圾回收器：当前大多数应用仍然使用JDK1.8，并且默认的年轻代垃圾回收器是ParallelScavenge。ParallelScavenge回收器旨在最大化吞吐量，适合对CPU使用率有较高要求的应用场景。AdaptiveSizePolicy：默认情况下，ParallelScavenge回收器启用了AdaptiveSizePolicy，该策略会动态调整Eden区和Surv
    
                    
    • 
                    
  • Java零基础入门「必学」知识点Java常用类视频教程_Java基础教程
                        计算机语言学习

                        
    在前面的课程中，我们知道了在学习Java中有各种各样的“类”来供我们学习，八种使用较为广泛的“类”知识点有：1.包装类2.String类3.StringBuffer和StringBuilder类4.Date类和DateFormat类5.Calendar类6.JDK8的日期类7.Math类和Random类8.枚举戳下方视频从零基础到精通，只差这一步喔~尚学堂给同学们带来全新的Java300集课程啦!
    
                    
    • 
                    
  • Java面向对象之接口—详细完整从0到1讲述接口以及使用（附有案例+代码）
                        蔚一
Java知识javapython开发语言idea数据结构算法
                        
    文章目录十六.接口16.1接口的定义和使用16.2类实现接口的要求和意义16.3接口中成员的特点16.4接口和类之间的关系16.6JDK8接口中的方法16.6.1默认方法16.6.2静态方法16.7JDK9接口中的私有方法十六.接口接口就是一种规则，是对行为的抽象接口是一种能力，一种约束jdk7以前：接口中只能定义抽象方法jdk8新特性：接口中可以定义有方法体的方法，该方法一种是默认方法，一种是静
    
                    
    • 
                    
  • 基于SpringBoot的校园二手交易平台
                        学途拾珍
好码分享springboot后端java二手交易
                        
    1.项目介绍基于SpringBoot实现的校园二手交易平台。技术框架：SpringBoot2.0.0+MyBatis1.3.2+Mysql5.7+Bootstrap运行环境：jdk8+IntelliJIDEA+maven3后台首页、菜单管理、角色管理、用户管理、日志管理、数据备份、分类管理、物品管理、求购物品、学生列表、评论列表、公告列表、友情链接、站点设置。2.安装教程下载源码，本地新建数据库，
    
                    
    • 
                    
  • CentOS7安装Jenkins-2.346.1，jdk8
                        Arvin627
jenkins
                        
    高版本的Jenkins需要jdk11甚至jdk17以上，但是公司项目大多都是基于jdk8，为了避免打包保jdk版本异常，直接安装支持jdk8的jenkins。Linux：centos7Git：git-1.8.3.1JDK：jdk-8u371Maven：maven-3.6.3Tomcat：tomcat-9.0.65Jenkins：jenkins-2.346.1（支持jdk8的最新版Jenkins）J
    
                    
    • 
                    
  • 基于SSM的运动会管理系统
                        学途拾珍
好码分享javaSSM运动会
                        
    由于知识付费平台暂停服务，需要的同学可以联系QQ：4984698491.项目介绍采用了Java语言和MySQL数据库来实现。系统按预定的算法完成了创办运动会、广播公告公示、赛事项目拟订、报名参赛、赛后成绩录入、查看比赛成绩、院系人员的信息存储、反馈建议、访问日记等功能。关键词：高校运动会；信息管理系统；JavaWeb；SSM管理员账号密码：admin/admin运行环境：jdk8+tomcat8+
    
                    
    • 
                    
  • JAVA基础面试题总结（十三）——JVM（中）
                        城南vision
jvmjava开发语言
                        
    堆空间的基本结构JDK7以及之前的版本，堆空间包括以下部分：新生代内存(YoungGeneration)老生代(OldGeneration)永久代(PermanentGeneration)JDK8版本之后PermGen(永久)已被Metaspace(元空间)取代，元空间使用的是直接内存。内存分配与回收原则1、对象优先在Eden区分配大多数情况下，对象在新生代中Eden区分配。当Eden区没有足够空
    
                    
    • 
                    
  • 搭建elk日志管理系统
                        阿色你过来啊
学习分享elkelasticsearch大数据
                        
    ELK日志管理系统一．环境准备按照JDK1.8第一步：下载JDKhttps://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html第二步：安装mkdir/usr/jdktar-xvfjdk-8u112-linux-x64.tar.gz/usr/jdk第三步：配置环境变量命令：vim/etc/pro
    
                    
    • 
                    
  • Android测试环境搭建之 ADB
                        Nubin4939

                        
    1.安装JDK官网下载并安装【根据系统下载对应的版本】http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html2.配置JAVA环境变量A.增加变量JAVA_HOME,值为JDK安装路径B.在PATH中增加%JAVA_HOME%\binC.在PATH中增加platform-tools文件夹的
    
                    
    • 
                    
  • Yolov8：模型部署到安卓端
                        爱编码的小陈
深度学习YOLO
                        
    1.项目准备1.1先安装JDK和Androidstudio（1）JDK下载：官网站：https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html同意协议后，下载相应版本的JDK我这里没有下载JDK21版的，下载的是jdk1.8版本，参考文章：AndroidStudio开发环境快速搭建（超详细
    
                    
    • 
                    
  • JDK各LTS版本下载，包含JDK8、11、17、21版本（文章末尾附带直接下载链接）
                        码码哈哈0.0
新人必知实用工具java开发语言
                        
    JDK各LTS版本下载，包含JDK8、11、17、21版本（文章末尾附带直接下载链接）前言最近oracle官网对于JDK的下载，需要先登录才能下载，整个过程显得麻烦又繁琐，在这里我为大家准备了各个LTS版本的下载链接，免费提供给大家，希望大家多多支持~LTS版本介绍“长期支持版本”（Long-TermSupport,LTS）在软件领域指的是一个版本会获得较长时间的支持，包括更新、补丁和安全修复。对
    
                    
    • 
                    
  • Hadoop入门基础（二）：Hadoop集群安装与部署详解（超详细教程）
                        william.zhang(张)
hadoop大数据分布式
                        
    一、环境准备1.集群规划首先，需要为集群中的每台机器设置角色和网络配置。在此示例中，我们使用三台机器：角色主机名IP地址NameNodemaster192.168.1.101DataNode1slave1192.168.1.102DataNode2slave2192.168.1.1032.软件要求操作系统：CentOS7或Ubuntu20.04JavaJDK：Hadoop需要JDK8或更高版本安装
    
                    
    • 
                                
  • Java实现的简单双向Map，支持重复Value
                                    superlxw1234
java双向map
                                    
    关键字：Java双向Map、DualHashBidiMap 
  
  
有个需求，需要根据即时修改Map结构中的Value值，比如，将Map中所有value=V1的记录改成value=V2，key保持不变。 
  
数据量比较大，遍历Map性能太差，这就需要根据Value先找到Key，然后去修改。 
  
即：既要根据Key找Value，又要根据Value
    
                                
    • 
                                
  • PL/SQL触发器基础及例子
                                    百合不是茶
oracle数据库触发器PL/SQL编程
                                    
      
触发器的简介; 
触发器的定义就是说某个条件成立的时候，触发器里面所定义的语句就会被自动的执行。因此触发器不需要人为的去调用，也不能调用。触发器和过程函数类似 过程函数必须要调用, 
  
一个表中最多只能有12个触发器类型的,触发器和过程函数相似 触发器不需要调用直接执行,


 
触发时间：指明触发器何时执行，该值可取：
before：表示在数据库动作之前触发
    
                                
    • 
                                
  • [时空与探索]穿越时空的一些问题
                                    comsci
问题
                                    
     
      我们还没有进行过任何数学形式上的证明,仅仅是一个猜想..... 
 
      这个猜想就是; 任何有质量的物体(哪怕只有一微克)都不可能穿越时空,该物体强行穿越时空的时候,物体的质量会与时空粒子产生反应,物体会变成暗物质,也就是说,任何物体穿越时空会变成暗物质..(暗物质就我的理
    
                                
    • 
                                
  • easy ui datagrid上移下移一行
                                    商人shang
js上移下移easyuidatagrid
                                    
    /**
 * 向上移动一行
 * 
 * @param dg
 * @param row
 */
function moveupRow(dg, row) {
	var datagrid = $(dg);
	var index = datagrid.datagrid("getRowIndex", row);
	if (isFirstRow(dg, row)) {
    
                                
    • 
                                
  • Java反射
                                    oloz
反射
                                    
    本人菜鸟，今天恰好有时间，写写博客，总结复习一下java反射方面的知识，欢迎大家探讨交流学习指教 
 
首先看看java中的Class 
 
package demo;

public class ClassTest {
	
	/*先了解java中的Class*/
	
	public static void main(String[] args) {
		
    //任何一个类都
    
                                
    • 
                                
  • springMVC 使用JSR-303 Validation验证
                                    杨白白
springmvc
                                    
    JSR-303是一个数据验证的规范，但是spring并没有对其进行实现，Hibernate Validator是实现了这一规范的，通过此这个实现来讲SpringMVC对JSR-303的支持。 
 JSR-303的校验是基于注解的，首先要把这些注解标记在需要验证的实体类的属性上或是其对应的get方法上。 
 
登录需要验证类 
 
public class Login {

	@NotEmpty
    
                                
    • 
                                
  • log4j
                                    香水浓
log4j
                                    
    
log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, HTML, DATABASE
#log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, ROLLINGFILE, HTML

#console
log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
log4
    
                                
    • 
                                
  • 使用ajax和history.pushState无刷新改变页面URL
                                    agevs
jquery框架Ajaxhtml5chrome
                                    
    表现 
如果你使用chrome或者firefox等浏览器访问本博客、github.com、plus.google.com等网站时，细心的你会发现页面之间的点击是通过ajax异步请求的，同时页面的URL发生了了改变。并且能够很好的支持浏览器前进和后退。 
是什么有这么强大的功能呢？ 
HTML5里引用了新的API，history.pushState和history.replaceState，就是通过
    
                                
    • 
                                
  • centos中文乱码
                                    AILIKES
centosOSssh
                                    
    一、CentOS系统访问 g.cn ，发现中文乱码。 
于是用以前的方式：yum -y install fonts-chinese 
CentOS系统安装后，还是不能显示中文字体。我使用 gedit 编辑源码，其中文注释也为乱码。     
  
      
  
后来，终于找到以下方法可以解决，需要两个中文支持的包： 
fonts-chinese-3.02-12.
    
                                
    • 
                                
  • 触发器
                                    baalwolf
触发器
                                    
    触发器(trigger)：监视某种情况，并触发某种操作。 
触发器创建语法四要素：1.监视地点(table) 2.监视事件(insert/update/delete) 3.触发时间(after/before) 4.触发事件(insert/update/delete) 
语法： 
create trigger triggerName 
after/before 
    
                                
    • 
                                
  • JS正则表达式的i m g
                                    bijian1013
JavaScript正则表达式
                                    
            g:表示全局（global)模式，即模式将被应用于所有字符串，而非在发现第一个匹配项时立即停止。         i:表示不区分大小写（case-insensitive）模式，即在确定匹配项时忽略模式与字符串的大小写。         m:表示
    
                                
    • 
                                
  • HTML5模式和Hashbang模式
                                    bijian1013
JavaScriptAngularJSHashbang模式HTML5模式
                                    
            我们可以用$locationProvider来配置$location服务（可以采用注入的方式，就像AngularJS中其他所有东西一样）。这里provider的两个参数很有意思，介绍如下。 
html5Mode 
        一个布尔值，标识$location服务是否运行在HTML5模式下。 
ha
    
                                
    • 
                                
  • [Maven学习笔记六]Maven生命周期
                                    bit1129
maven
                                    
    从mvn test的输出开始说起 
  
当我们在user-core中执行mvn test时，执行的输出如下： 
  
/software/devsoftware/jdk1.7.0_55/bin/java -Dmaven.home=/software/devsoftware/apache-maven-3.2.1 -Dclassworlds.conf=/software/devs
    
                                
    • 
                                
  • 【Hadoop七】基于Yarn的Hadoop Map Reduce容错
                                    bit1129
hadoop
                                    
    运行于Yarn的Map Reduce作业，可能发生失败的点包括 
 
 Task Failure 
 Application Master Failure 
 Node Manager Failure 
 Resource Manager Failure 
 1. Task Failure 
任务执行过程中产生的异常和JVM的意外终止会汇报给Application Master。僵死的任务也会被A
    
                                
    • 
                                
  • 记一次数据推送的异常解决端口解决
                                    ronin47
记一次数据推送的异常解决
                                    
    　　 需求：从db获取数据然后推送到B 
        程序开发完成，上jboss,刚开始报了很多错，逐一解决，可最后显示连接不到数据库。机房的同事说可以ping 通。 
　　  自已画了个图，逐一排除，把linux 防火墙　和　setenforce　设置最低。 
　　　service iptables stop 

    
                                
    • 
                                
  • 巧用视错觉-UI更有趣
                                    brotherlamp
UIui视频ui教程ui自学ui资料
                                    
    我们每个人在生活中都曾感受过视错觉（optical illusion）的魅力。 
视错觉现象是双眼跟我们开的一个玩笑，而我们往往还心甘情愿地接受我们看到的假象。其实不止如此，视觉错现象的背后还有一个重要的科学原理——格式塔原理。 
格式塔原理解释了人们如何以视觉方式感觉物体，以及图像的结构，视角，大小等要素是如何影响我们的视觉的。 
在下面这篇文章中，我们首先会简单介绍一下格式塔原理中的基本概念，
    
                                
    • 
                                
  • 线段树-poj1177-N个矩形求边长（离散化+扫描线）
                                    bylijinnan
数据结构算法线段树
                                    
    package com.ljn.base;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

/**
 * POJ 1177 (线段树+离散化+扫描线)，题目链接为http://poj.org/problem?id=1177

    
                                
    • 
                                
  • HTTP协议详解
                                    chicony
http协议
                                    
    引言                                 
    
                                
    • 
                                
  • Scala设计模式
                                    chenchao051
设计模式scala
                                    
    Scala设计模式 
        
       我的话： 在国外网站上看到一篇文章，里面详细描述了很多设计模式，并且用Java及Scala两种语言描述，清晰的让我们看到各种常规的设计模式，在Scala中是如何在语言特性层面直接支持的。基于文章很nice，我利用今天的空闲时间将其翻译，希望大家能一起学习，讨论。翻译
    
                                
    • 
                                
  • 安装mysql
                                    daizj
mysql安装
                                    
    安装mysql 
  (1)删除linux上已经安装的mysql相关库信息。rpm  -e  xxxxxxx   --nodeps (强制删除) 
     执行命令rpm -qa |grep mysql 检查是否删除干净 
  (2)执行命令  rpm -i MySQL-server-5.5.31-2.el
    
                                
    • 
                                
  • HTTP状态码大全
                                    dcj3sjt126com
http状态码
                                    
    完整的 HTTP 1.1规范说明书来自于RFC 2616，你可以在http://www.talentdigger.cn/home/link.php?url=d3d3LnJmYy1lZGl0b3Iub3JnLw%3D%3D在线查阅。HTTP 1.1的状态码被标记为新特性，因为许多浏览器只支持 HTTP 1.0。你应只把状态码发送给支持 HTTP 1.1的客户端，支持协议版本可以通过调用request
    
                                
    • 
                                
  • asihttprequest上传图片
                                    dcj3sjt126com
ASIHTTPRequest
                                    
    NSURL *url =@"yourURL";
    ASIFormDataRequest*currentRequest =[ASIFormDataRequest requestWithURL:url];
    [currentRequest setPostFormat:ASIMultipartFormDataPostFormat];[currentRequest se
    
                                
    • 
                                
  • C语言中，关键字static的作用
                                    e200702084
C++cC#
                                    
    在C语言中，关键字static有三个明显的作用： 
 
1)在函数体，局部的static变量。生存期为程序的整个生命周期，（它存活多长时间）；作用域却在函数体内（它在什么地方能被访问（空间））。 
一个被声明为静态的变量在这一函数被调用过程中维持其值不变。因为它分配在静态存储区，函数调用结束后并不释放单元，但是在其它的作用域的无法访问。当再次调用这个函数时，这个局部的静态变量还存活，而且用在它的访
    
                                
    • 
                                
  • win7/8使用curl
                                    geeksun
win7
                                    
    1.  WIN7/8下要使用curl，需要下载curl-7.20.0-win64-ssl-sspi.zip和Win64OpenSSL_Light-1_0_2d.exe。  下载地址：  
http://curl.haxx.se/download.html   请选择不带SSL的版本，否则还需要安装SSL的支持包       2.  可以给Windows增加c
    
                                
    • 
                                
  • Creating a Shared Repository; Users Sharing The Repository
                                    hongtoushizi
git
                                    
    转载自：  
http://www.gitguys.com/topics/creating-a-shared-repository-users-sharing-the-repository/  Commands discussed in this section: 
 
 git init –bare 
 git clone 
 git remote 
 git pull 
 git p
    
                                
    • 
                                
  • Java实现字符串反转的8种或9种方法
                                    Josh_Persistence
异或反转递归反转二分交换反转java字符串反转栈反转
                                    
    注：对于第7种使用异或的方式来实现字符串的反转，如果不太看得明白的，可以参照另一篇博客： 
http://josh-persistence.iteye.com/blog/2205768 
  
/**
 * 
 */
package com.wsheng.aggregator.algorithm.string;

import java.util.Stack;

/**

    
                                
    • 
                                
  • 代码实现任意容量倒水问题
                                    home198979
PHP算法倒水
                                    
    形象化设计模式实战             HELLO!架构                     redis命令源码解析 
  
倒水问题：有两个杯子，一个A升，一个B升，水有无限多，现要求利用这两杯子装C
    
                                
    • 
                                
  • Druid datasource
                                    zhb8015
druid
                                    
    推荐大家使用数据库连接池 DruidDataSource. http://code.alibabatech.com/wiki/display/Druid/DruidDataSource DruidDataSource经过阿里巴巴数百个应用一年多生产环境运行验证，稳定可靠。 它最重要的特点是：监控、扩展和性能。 下载和Maven配置看这里： http
    
                                
    • 
                                
  • 两种启动监听器ApplicationListener和ServletContextListener
                                    spjich
javaspring框架
                                    
    引言:有时候需要在项目初始化的时候进行一系列工作，比如初始化一个线程池，初始化配置文件，初始化缓存等等，这时候就需要用到启动监听器，下面分别介绍一下两种常用的项目启动监听器 
  
ServletContextListener  
特点: 依赖于sevlet容器，需要配置web.xml 
使用方法: 
public class StartListener implements 
    
                                
    • 
                                
  • JavaScript Rounding Methods of the Math object
                                    何不笑
JavaScriptMath
                                    
        The next group of methods has to do with rounding decimal values into integers. Three methods — Math.ceil(),  Math.floor(), and  Math.round() — handle rounding in differen
    
                                
    •