Spring入门到放弃篇（1）-国际化

Java原生国际化

文档地址

java官方文档

参考官方文档

自定义国际化案例

public class LocaleDemo {
    public static void main(String[] args) {
        System.out.println(Locale.getDefault());
    }
}

获取本地方言

配置本地方言

• 通过启动参数-D命令配置

  • 但是这种方式只适合本机
• Locale.setDefault(Locale.US);

国际化数字

public class NumberFormatDemo {

  public static void main(String[] args) {
    NumberFormat numberFormat = NumberFormat.getNumberInstance();
    System.out.println(numberFormat.format(10000));//10,000

    numberFormat = NumberFormat.getNumberInstance(Locale.FRANCE);
    System.out.println(numberFormat.format(10000));//10 000
  }
}

通过不同的方言来决定数字的显示方式

ResourceBundle国际化

创建一个demo_zh_CN.properties在resources目录

name=测试
world=你好,{0}

public class ResourceBundleDemo {
  public static final String BUNDLE_NAME = "demo";

  public static void main(String[] args) {
    getEn();
    getZhCn();
  }
  private static void getZhCn() {
    Locale.setDefault(Locale.SIMPLIFIED_CHINESE);
    ResourceBundle demo2 = ResourceBundle.getBundle(BUNDLE_NAME);

    //因为当前没有使用unicode来写，默认是iso_8859_1,所以转化，避免乱码
    System.out.println(new String(demo2.getString("name").getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8));
  }


  private static void getEn() {
    Locale.setDefault(Locale.ENGLISH);
    ResourceBundle demo = ResourceBundle.getBundle(BUNDLE_NAME);
    String test = demo.getString("name");
    System.out.println(test);
  }
}

​ 上述代码中通过java.util.ResourceBundle来做国际化转化，但是因为properties文件中的国际化内容默认采用的是ISO 8895-1所以只要出现的是中文就会乱码。当前我们使用的是通过字符串编解码来转化的。

国际化乱码问题

​ 从上述案例中我们可以看到中文会乱码。

解决方式有以下三种：

• 可以采用jdk自带的工具 native2ascii 方法，将打包后的资源文件进行转移，而不是直接在源码方面解决

• 扩展 ResourceBundle.Control

  • 缺点：可移植性不强，不得不显示地传递
• 实现 ResourceBundleControlProvider

jdk自带的native2ascii

工具文档地址

java支持的编码

  native2ascii demo_zh_CN.properties demo_zh_CN_ascii.properties

转化后文件内容如下

name=\u6d4b\u8bd5
world=\u4f60\u597d,{0}

扩展java.util.ResourceBundle.Control

从java.util.ResourceBundle.Control#newBundle可以看到java.util.ResourceBundle是从这里生产出来的。

核心代码如下

final String resourceName = toResourceName0(bundleName, "properties");
if (resourceName == null) {
  return bundle;
}
final ClassLoader classLoader = loader;
final boolean reloadFlag = reload;
InputStream stream = null;
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) {
              // Disable caches to get fresh data for
              // reloading.
              connection.setUseCaches(false);
              is = connection.getInputStream();
            }
          }
        } else {
          is = classLoader.getResourceAsStream(resourceName);
        }
        return is;
      }
    });
} catch (PrivilegedActionException e) {
  throw (IOException) e.getException();
}
if (stream != null) {
  try {
    //把读取到的流装载到PropertyResourceBundle中
    bundle = new PropertyResourceBundle(stream);
  } finally {
    stream.close();
  }
}

java.util.PropertyResourceBundle#PropertyResourceBundle(java.io.InputStream)

public PropertyResourceBundle (InputStream stream) throws IOException {
  Properties properties = new Properties();
  properties.load(stream);
  lookup = new HashMap(properties);
}

断点查看，在Peroerties加载stream的时候出现了乱码。

所以我们可以在获取到流的时候，直接定义流的编码就行了

所以照葫芦画瓢，修改代码如下

public class EncodedControl extends ResourceBundle.Control {
  private final String encoding;

  public EncodedControl(String encoding) {
    this.encoding = encoding;
  }

  @Override
  public ResourceBundle newBundle(String baseName, Locale locale, String format,
                                  ClassLoader loader, boolean reload)
    throws IllegalAccessException, InstantiationException, IOException {
    String bundleName = toBundleName(baseName, locale);
    ResourceBundle bundle = null;
    if (format.equals("java.class")) {
      try {
        @SuppressWarnings("unchecked")
        Class bundleClass
          = (Class) loader.loadClass(bundleName);

        // If the class isn't a ResourceBundle subclass, throw a
        // ClassCastException.
        if (ResourceBundle.class.isAssignableFrom(bundleClass)) {
          bundle = bundleClass.newInstance();
        } else {
          throw new ClassCastException(bundleClass.getName()
                                       + " cannot be cast to ResourceBundle");
        }
      } catch (ClassNotFoundException e) {
      }
    } else if (format.equals("java.properties")) {
      final String resourceName = toResourceName0(bundleName, "properties");
      if (resourceName == null) {
        return bundle;
      }
      final ClassLoader classLoader = loader;
      final boolean reloadFlag = reload;
      InputStream stream = null;
      try {
        stream = AccessController.doPrivileged(
          new PrivilegedExceptionAction() {
            @Override
            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) {
                    // Disable caches to get fresh data for
                    // reloading.
                    connection.setUseCaches(false);
                    is = connection.getInputStream();
                  }
                }
              } else {
                is = classLoader.getResourceAsStream(resourceName);
              }
              return is;
            }
          });
      } catch (PrivilegedActionException e) {
        throw (IOException) e.getException();
      }
      Reader reader = null;
      if (stream != null) {
        try {
          //增加转码
          reader = new InputStreamReader(stream, encoding);

          bundle = new PropertyResourceBundle(reader);
        } finally {
          reader.close();
          stream.close();
        }
      }
    } else {
      throw new IllegalArgumentException("unknown format: " + format);
    }
    return bundle;
  }

  private String toResourceName0(String bundleName, String suffix) {
    // application protocol check
    if (bundleName.contains("://")) {
      return null;
    } else {
      return toResourceName(bundleName, suffix);
    }
  }
}

修改代码

/**
     * 基于 Java 1.6
     * 显示地传递 EncodedControl
     */
    private static void extendControl() {
        Locale.setDefault(Locale.SIMPLIFIED_CHINESE);
        ResourceBundle resourceBundle = ResourceBundle.getBundle(BUNDLE_NAME, new EncodedControl("utf8"));
        System.out.println("resourceBundle.name : " + resourceBundle.getString("name"));
    }

测试，发现成功了。

但是这种方式可移植性不强，不得不显示地传递 ResourceBundle.Control所以我们采用下面这种方式

实现ResourceBundleControlProvider

在

static {
  List list = null;
  ServiceLoader serviceLoaders
    = ServiceLoader.loadInstalled(ResourceBundleControlProvider.class);
  for (ResourceBundleControlProvider provider : serviceLoaders) {
    if (list == null) {
      list = new ArrayList<>();
    }
    list.add(provider);
  }
  providers = list;
}

这里可以看到，当我们ResourceBundle初始化的时候会基于SPI自动加载provider,在java.util.ResourceBundle#getDefaultControl这里可以看到

private static Control getDefaultControl(String baseName) {
  if (providers != null) {
    for (ResourceBundleControlProvider provider : providers) {
      Control control = provider.getControl(baseName);
      if (control != null) {
        return control;
      }
    }
  }
  return Control.INSTANCE;
}

获取默认的java.util.ResourceBundle.Control前会尝试从java.util.spi.ResourceBundleControlProvider中获取，所以我们可以自定义java.util.spi.ResourceBundleControlProvider来生成对应的control

SPI

SPI官方地址

spi原理具体见java.util.ServiceLoader.LazyIterator#hasNextService

private static final String PREFIX = "META-INF/services/";

编写代码

public class EncodingResourceBundleControlProvider implements ResourceBundleControlProvider {

  @Override
  public ResourceBundle.Control getControl(String baseName) {
    return new EncodedControl();
  }
}

然后按照文档

在META-INF/services创建java.util.spi.ResourceBundleControlProvider文件

内容为

com.zzjson.se.provider.EncodingResourceBundleControlProvider

最后测试

但是发现失效！！！

原因resourceBundle中spi调用的是java.util.ServiceLoader#loadInstalled这里面不会加载项目中的配置

Spring国际化

MessageSource-消息转化的顶层接口

Spring-messageSource，介绍文档地址

public interface MessageSource {

  //用于从MessageSource检索消息的基本方法。 如果找不到指定语言环境的消息，则使用默认消息。 使用标准库提供的MessageFormat功能，传入的所有参数都将成为替换值。
    String getMessage(String code, Object[] args, String defaultMessage, Locale locale);

    //与先前的方法基本相同，但有一个区别：无法指定默认消息；默认值为0。 如果找不到消息，则抛出NoSuchMessageException。
    String getMessage(String code, Object[] args, Locale locale) throws NoSuchMessageException;

    //前述方法中使用的所有属性也都包装在一个名为MessageSourceResolvable的类中，您可以在此方法中使用该类。
    String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException;

}

加载ApplicationContext时，它将自动搜索在上下文中定义的MessageSource bean。

​ Bean必须具有名称messageSource。 如果找到了这样的bean，则对先前方法的所有调用都将委派给消息源。

​ 如果找不到消息源，则ApplicationContext尝试查找包含同名bean的父级。 如果是这样，它将使用该bean作为MessageSource。

​ 如果ApplicationContext找不到任何消息源，则将实例化一个空的org.springframework.context.support.DelegatingMessageSource，以便能够接受对上述方法的调用。

MessageSourceResolvable

org.springframework.context.MessageSourceResolvable

public interface MessageSourceResolvable {

  String[] getCodes();

  Object[] getArguments();

  String getDefaultMessage();

}

类图

当前我们只需要关注这一块就行了

HierarchicalMessageSource

public interface HierarchicalMessageSource extends MessageSource {

    void setParentMessageSource(MessageSource parent);

    MessageSource getParentMessageSource();
}

MessageSourceSupport

MessageFormat

MessageFormat是java提供的他的包在java.text,他能帮我们格式化文本

MessageSourceSupport和MessageFormat密切相关我们先看看MessageFormat的案例

public class MessageFormatDemo {
  /**
    * @param args
    * @see ResourceBundleMessageSource#resolveCode(java.lang.String, java.util.Locale)
    */
  public static void main(String[] args) {
    MessageFormat format = new MessageFormat("Hello,{0}!");
    System.out.println(format.format(new Object[]{"World"}));
  }

}

• MessageFormat能够帮我们填充参数java.text.MessageFormat#subformat

​ 回到org.springframework.context.support.MessageSourceSupport可以看到其提供了标准的java.text.MessageFormat功能查看其核心代码

public abstract class MessageSourceSupport {
  private static final MessageFormat INVALID_MESSAGE_FORMAT = new MessageFormat("");


  private boolean alwaysUseMessageFormat = false;

  private final Map> messageFormatsPerMessage =
    new HashMap>();

  //使用缓存的MessageFormats格式化给定的消息字符串。默认情况下，将为传入的默认消息调用，以解析在其中找到的所有参数占位符。
  protected String formatMessage(String msg, Object[] args, Locale locale) {
    if (msg == null || (!isAlwaysUseMessageFormat() && 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 {
        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));
    }
  }

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

从代码中可见org.springframework.context.support.MessageSourceSupport主要提供了一下几个功能

• 使用创建对应的Messageformat
• 缓存语言环境和对应的MessageFormat

AbstractMessageSource模板类

org.springframework.context.support.AbstractMessageSource 实现消息的通用处理，从而可以轻松地针对具体的MessageSource实施特定策略。

先看AbstractMessageSource对于MessageSource的默认实现

@Override
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);
}

@Override
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);
}

@Override
public final String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException {
  String[] codes = resolvable.getCodes();
  if (codes != null) {
    for (String code : codes) {
      String message = getMessageInternal(code, resolvable.getArguments(), locale);
      if (message != null) {
        return message;
      }
    }
  }
  String defaultMessage = getDefaultMessage(resolvable, locale);
  if (defaultMessage != null) {
    return defaultMessage;
  }
  throw new NoSuchMessageException(!ObjectUtils.isEmpty(codes) ? codes[codes.length - 1] : null, locale);
}

结合前面说的MessageSource接口的定义我们不难看出这里有两个核心的方法

• org.springframework.context.support.AbstractMessageSource#getMessageInternal

  • 在给定的语言环境中将给定的代码和参数解析为消息

• org.springframework.context.support.AbstractMessageSource#getDefaultMessage(org.springframework.context.MessageSourceResolvable, java.util.Locale)

  • 如果上述解析出来的Message是空的，则通过此方法获取默认消息

getDefaultMessage

protected String getDefaultMessage(MessageSourceResolvable resolvable, Locale locale) {
  String defaultMessage = resolvable.getDefaultMessage();
  String[] codes = resolvable.getCodes();
  if (defaultMessage != null) {
    if (!ObjectUtils.isEmpty(codes) && defaultMessage.equals(codes[0])) {
      // Never format a code-as-default-message, even with alwaysUseMessageFormat=true
      return defaultMessage;
    }
    //调用前面说到的`org.springframework.context.support.MessageSourceSupport#renderDefaultMessage`
    return renderDefaultMessage(defaultMessage, resolvable.getArguments(), locale);
  }
  return (!ObjectUtils.isEmpty(codes) ? getDefaultMessage(codes[0]) : null);
}

​ 从这里可以看到就是把参数传递给了我们前面说的MessageSourceSupport中的方法然后对传入的参数基于语言环境进行了格式化

getMessageInternal

org.springframework.context.support.AbstractMessageSource#getMessageInternal

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)) {
    // 当前代码可能需要优化，因为我们并不需要参数因此不需要涉及MessageFormat。但是实际上还是使用了MessageFormat去格式化消息
    //注意，默认实现仍使用MessageFormat； 
    //这可以在特定的子类中覆盖

    String message = resolveCodeWithoutArguments(code, locale);
    if (message != null) {
      return message;
    }
  }

  else {
    //对于在父MessageSource中定义了消息
    //而在子MessageSource中定义了可解析参数的情况，直接子MessageSource就解析参数。
    //把需要解析的参数封装到数组中
    argsToUse = resolveArguments(args, locale);

    MessageFormat messageFormat = resolveCode(code, locale);
    if (messageFormat != null) {
      synchronized (messageFormat) {
        //使用消息格式化器来格式
        return messageFormat.format(argsToUse);
      }
    }
  }

  //如果上面都没有找到合适的解析器，即子类没有返回MessageFormat，则从语言环境无关的公共消息中的给定消息代码
  //private Properties commonMessages;
 // 当前commonMessage就是Properties
  Properties commonMessages = getCommonMessages();
  if (commonMessages != null) {
    String commonMessage = commonMessages.getProperty(code);
    if (commonMessage != null) {
      return formatMessage(commonMessage, args, locale);
    }
  }

  //如果都没有找到，就从父节点找
  return getMessageFromParent(code, argsToUse, locale);
}

@Override
//把需要解析的参数封装到数组中
    protected Object[] resolveArguments(Object[] args, Locale locale) {
        if (args == null) {
            return new Object[0];
        }
        List