Jak używać UTF-8 we właściwościach zasobów z ResourceBundle

Muszę użyć UTF-8 we właściwościach zasobów za pomocą Java ResourceBundle. Kiedy wprowadzam tekst bezpośrednio do pliku właściwości, wyświetla się on jako mojibake.

Moja aplikacja działa na Google App Engine.

Czy ktoś może dać mi przykład? Nie mogę dostać tej pracy.

Do ResourceBundle#getBundle()zastosowania pod kołdrą PropertyResourceBundle, gdy .propertiesplik jest określona. To z kolei domyślnie używa Properties#load(InputStream)do ładowania tych plików właściwości. Zgodnie z javadoc są one domyślnie czytane jako ISO-8859-1.

public void load(InputStream inStream) throws IOException

Odczytuje listę właściwości (pary kluczy i elementów) z wejściowego strumienia bajtów. Strumień wejściowy jest w prostym formacie zorientowanym liniowo, określonym w load (Reader) i zakłada się, że wykorzystuje kodowanie znaków ISO 8859-1 ; to znaczy, że każdy bajt to jeden znak Latin1. Znaki spoza alfabetu łacińskiego 1 oraz niektóre znaki specjalne są reprezentowane w kluczach i elementach za pomocą znaków ucieczki Unicode zgodnie z definicją w sekcji 3.3 specyfikacji języka Java ™.

Musisz więc zapisać je jako ISO-8859-1. Jeśli masz jakieś znaki poza zakresem ISO-8859-1 i nie możesz użyć \uXXXXczubka głowy, a zatem jesteś zmuszony zapisać plik jako UTF-8, musisz użyć narzędzia native2ascii do konwersji Plik właściwości zapisanych w UTF-8 do pliku właściwości zapisanych w ISO-8859-1, w którym wszystkie odkryte znaki są konwertowane na \uXXXXformat. Poniższy przykład konwertuje plik właściwości zakodowany w UTF-8 text_utf8.propertiesna prawidłowy plik właściwości zakodowany w standardzie ISO-8859-1 text.properties.

native2ascii -encoding UTF-8 text_utf8.properties text.properties

Gdy używasz rozsądnego IDE, takiego jak Eclipse, jest to już automatycznie wykonywane, gdy tworzysz .propertiesplik w projekcie opartym na Javie i używasz własnego edytora Eclipse. Eclipse w sposób przezroczysty konwertuje znaki spoza zakresu ISO-8859-1 na \uXXXXformat. Zobacz także poniższe zrzuty ekranu (zwróć uwagę na zakładki „Właściwości” i „Źródło” u dołu, kliknij, aby wyświetlić duże):

Alternatywnie, możesz również utworzyć niestandardową ResourceBundle.Controlimplementację, w której bezpośrednio odczytujesz pliki właściwości jako UTF-8 InputStreamReader, dzięki czemu możesz po prostu zapisać je jako UTF-8 bez konieczności kłopotania się native2ascii. Oto przykład:

public class UTF8Control extends Control {
    public ResourceBundle newBundle
        (String baseName, Locale locale, String format, ClassLoader loader, boolean reload)
            throws IllegalAccessException, InstantiationException, IOException
    {
        // The below is a copy of the default implementation.
        String bundleName = toBundleName(baseName, locale);
        String resourceName = toResourceName(bundleName, "properties");
        ResourceBundle bundle = null;
        InputStream stream = null;
        if (reload) {
            URL url = loader.getResource(resourceName);
            if (url != null) {
                URLConnection connection = url.openConnection();
                if (connection != null) {
                    connection.setUseCaches(false);
                    stream = connection.getInputStream();
                }
            }
        } else {
            stream = loader.getResourceAsStream(resourceName);
        }
        if (stream != null) {
            try {
                // Only this line is changed to make it to read properties files as UTF-8.
                bundle = new PropertyResourceBundle(new InputStreamReader(stream, "UTF-8"));
            } finally {
                stream.close();
            }
        }
        return bundle;
    }
}

Można to wykorzystać w następujący sposób:

ResourceBundle bundle = ResourceBundle.getBundle("com.example.i18n.text", new UTF8Control());

Zobacz też:

• Unicode - Jak poprawnie ustawić znaki?

Biorąc pod uwagę, że masz instancję ResourceBundle i możesz uzyskać ciąg znaków przez:

String val = bundle.getString(key); 

Rozwiązałem mój japoński problem z wyświetlaniem poprzez:

return new String(val.getBytes("ISO-8859-1"), "UTF-8");

Spójrz na to : http://docs.oracle.com/javase/6/docs/api/java/util/Properties.html#load(java.io.Reader)

właściwości akceptują Czytnika obiekt jako argumenty, które można utworzyć z InputStream.

w czasie tworzenia możesz określić kodowanie Czytnika:

InputStreamReader isr = new InputStreamReader(stream, "UTF-8");

następnie zastosuj ten czytnik do metody ładowania:

prop.load(isr);

BTW: pobierz strumień z pliku .properties :

 InputStream stream = this.class.getClassLoader().getResourceAsStream("a.properties");

BTW: pobierz pakiet zasobów od InputStreamReader:

ResourceBundle rb = new PropertyResourceBundle(isr);

mam nadzieję, że to może ci pomóc!

ResourceBundle.Control z UTF-8 i nowymi metodami String nie działają, jeśli na przykład plik właściwości używa zestawu znaków cp1251.

Dlatego polecam, używając wspólnej metody: pisz w symbolach Unicode . Dla tego:

IDEA - posiada specjalną opcję „ Przezroczysta konwersja natywnego na ASCII ” (Ustawienia> Kodowanie pliku).

Eclipse - ma wtyczkę „ Edytor właściwości ” . Może działać jako osobna aplikacja.

Ten problem został wreszcie rozwiązany w Javie 9: https://docs.oracle.com/javase/9/intl/internationalization-enhancements-jdk-9

Domyślne kodowanie plików właściwości to teraz UTF-8.

Nie powinno to mieć wpływu na większość istniejących plików właściwości: UTF-8 i ISO-8859-1 mają to samo kodowanie znaków ASCII, a kodowanie ISO-8859-1 czytelne dla człowieka nie jest prawidłowe UTF-8. W przypadku wykrycia nieprawidłowej sekwencji bajtów UTF-8 środowisko wykonawcze Java automatycznie ponownie odczytuje plik w ISO-8859-1.

Tworzymy plik resources.utf8, który zawiera zasoby w UTF-8 i mamy regułę do uruchamiania następujących czynności:

native2ascii -encoding utf8 resources.utf8 resources.properties

package com.varaneckas.utils;  

import java.io.UnsupportedEncodingException;  
import java.util.Enumeration;  
import java.util.PropertyResourceBundle;  
import java.util.ResourceBundle;  

/** 
 * UTF-8 friendly ResourceBundle support 
 *  
 * Utility that allows having multi-byte characters inside java .property files. 
 * It removes the need for Sun's native2ascii application, you can simply have 
 * UTF-8 encoded editable .property files. 
 *  
 * Use:  
 * ResourceBundle bundle = Utf8ResourceBundle.getBundle("bundle_name"); 
 *  
 * @author Tomas Varaneckas <[email protected]> 
 */  
public abstract class Utf8ResourceBundle {  

    /** 
     * Gets the unicode friendly resource bundle 
     *  
     * @param baseName 
     * @see ResourceBundle#getBundle(String) 
     * @return Unicode friendly resource bundle 
     */  
    public static final ResourceBundle getBundle(final String baseName) {  
        return createUtf8PropertyResourceBundle(  
                ResourceBundle.getBundle(baseName));  
    }  

    /** 
     * Creates unicode friendly {@link PropertyResourceBundle} if possible. 
     *  
     * @param bundle  
     * @return Unicode friendly property resource bundle 
     */  
    private static ResourceBundle createUtf8PropertyResourceBundle(  
            final ResourceBundle bundle) {  
        if (!(bundle instanceof PropertyResourceBundle)) {  
            return bundle;  
        }  
        return new Utf8PropertyResourceBundle((PropertyResourceBundle) bundle);  
    }  

    /** 
     * Resource Bundle that does the hard work 
     */  
    private static class Utf8PropertyResourceBundle extends ResourceBundle {  

        /** 
         * Bundle with unicode data 
         */  
        private final PropertyResourceBundle bundle;  

        /** 
         * Initializing constructor 
         *  
         * @param bundle 
         */  
        private Utf8PropertyResourceBundle(final PropertyResourceBundle bundle) {  
            this.bundle = bundle;  
        }  

        @Override  
        @SuppressWarnings("unchecked")  
        public Enumeration getKeys() {  
            return bundle.getKeys();  
        }  

        @Override  
        protected Object handleGetObject(final String key) {  
            final String value = bundle.getString(key);  
            if (value == null)  
                return null;  
            try {  
                return new String(value.getBytes("ISO-8859-1"), "UTF-8");  
            } catch (final UnsupportedEncodingException e) {  
                throw new RuntimeException("Encoding not supported", e);  
            }  
        }  
    }  
}  

Uwaga: pliki właściwości java powinny być zakodowane w ISO 8859-1!

Kodowanie znaków ISO 8859-1. Znaki, które nie mogą być bezpośrednio reprezentowane w tym kodowaniu, mogą być pisane przy pomocy znaków ucieczki Unicode; tylko jeden znak „u” jest dozwolony w sekwencji ucieczki.

@ patrz Właściwości Java Doc

Jeśli nadal naprawdę chcesz to zrobić: spójrz na: Właściwości Java Kodowanie UTF-8 w Eclipse - istnieje kilka przykładów kodu

http://sourceforge.net/projects/eclipse-rbe/

jak już wspomniano, pliki właściwości powinny być zakodowane w ISO 8859-1

Możesz użyć powyższej wtyczki dla środowiska IDE Eclipse, aby wykonać dla Ciebie konwersję Unicode.

Oto rozwiązanie Java 7, które wykorzystuje doskonałą bibliotekę wsparcia Guava i konstrukcję try-with-resources. Odczytuje i zapisuje pliki właściwości za pomocą UTF-8 dla najprostszego ogólnego doświadczenia.

Aby odczytać plik właściwości jako UTF-8:

File file =  new File("/path/to/example.properties");

// Create an empty set of properties
Properties properties = new Properties();

if (file.exists()) {

  // Use a UTF-8 reader from Guava
  try (Reader reader = Files.newReader(file, Charsets.UTF_8)) {
    properties.load(reader);
  } catch (IOException e) {
    // Do something
  }
}

Aby zapisać plik właściwości jako UTF-8:

File file =  new File("/path/to/example.properties");

// Use a UTF-8 writer from Guava
try (Writer writer = Files.newWriter(file, Charsets.UTF_8)) {
  properties.store(writer, "Your title here");
  writer.flush();
} catch (IOException e) {
  // Do something
}

Jak sugerowano, przeszedłem implementację pakietu zasobów ... ale to nie pomogło .. ponieważ pakiet zawsze był wywoływany w ustawieniach regionalnych en_US ... próbowałem ustawić moje domyślne ustawienia regionalne na inny język, a mimo to moją implementację pakietu zasobów kontrola była wywoływana za pomocą en_US ... próbowałem umieścić komunikaty w dzienniku i zrobić krok przez debugowanie i sprawdzić, czy po zmianie ustawień regionalnych w czasie wykonywania przez xhtml i JSF wykonano inne lokalne połączenie ... to się nie stało ... potem próbowałem zrobić zestaw systemowy ustawiony domyślnie na utf8 do odczytu plików przez mój serwer (serwer tomcat) .. ale to spowodowało zaimek, ponieważ wszystkie moje biblioteki klas nie zostały skompilowane pod utf8 i tomcat zaczął czytać w formacie utf8 a serwer nie działał poprawnie ... skończyłem z implementacją metody w moim kontrolerze Java, która ma być wywoływana z plików xhtml ..w tej metodzie wykonałem następujące czynności:

        public String message(String key, boolean toUTF8) throws Throwable{
            String result = "";
            try{
                FacesContext context = FacesContext.getCurrentInstance();
                String message = context.getApplication().getResourceBundle(context, "messages").getString(key);

                result = message==null ? "" : toUTF8 ? new String(message.getBytes("iso8859-1"), "utf-8") : message;
            }catch(Throwable t){}
            return result;
        }

Byłem szczególnie zdenerwowany, ponieważ może to spowolnić działanie mojej aplikacji ... jednak po jej wdrożeniu wygląda to tak, jakby moja aplikacja była teraz szybsza. Myślę, że dzieje się tak, ponieważ teraz bezpośrednio uzyskuję dostęp do właściwości, a nie pozwalam JSF analizuje sposób uzyskiwania dostępu do właściwości ... w tym wywołaniu przekazuję argument boolowski, ponieważ wiem, że niektóre właściwości nie zostałyby przetłumaczone i nie muszą być w formacie utf8 ...

Teraz zapisałem plik właściwości w formacie UTF8 i działa dobrze, ponieważ każdy użytkownik w mojej aplikacji ma preferencyjne ustawienia regionalne.

Properties prop = new Properties();
String fileName = "./src/test/resources/predefined.properties";
FileInputStream inputStream = new FileInputStream(fileName);
InputStreamReader reader = new InputStreamReader(inputStream,"UTF-8");

Warto zwrócić uwagę na to, że same pliki miały niewłaściwe kodowanie. Korzystanie z iconv działało dla mnie

iconv -f ISO-8859-15 -t UTF-8  messages_nl.properties > messages_nl.properties.new

Próbowałem zastosować podejście dostarczone przez Rod, ale biorąc pod uwagę obawy BalusC o to, że nie powtarza się tego samego obejścia we wszystkich aplikacjach, otrzymałem tę klasę:

import java.io.UnsupportedEncodingException;
import java.util.Locale;
import java.util.ResourceBundle;

public class MyResourceBundle {

    // feature variables
    private ResourceBundle bundle;
    private String fileEncoding;

    public MyResourceBundle(Locale locale, String fileEncoding){
        this.bundle = ResourceBundle.getBundle("com.app.Bundle", locale);
        this.fileEncoding = fileEncoding;
    }

    public MyResourceBundle(Locale locale){
        this(locale, "UTF-8");
    }

    public String getString(String key){
        String value = bundle.getString(key); 
        try {
            return new String(value.getBytes("ISO-8859-1"), fileEncoding);
        } catch (UnsupportedEncodingException e) {
            return value;
        }
    }
}

Sposób użycia tego byłby bardzo podobny do zwykłego użycia ResourceBundle:

private MyResourceBundle labels = new MyResourceBundle("es", "UTF-8");
String label = labels.getString(key)

Lub możesz użyć alternatywnego konstruktora, który domyślnie używa UTF-8:

private MyResourceBundle labels = new MyResourceBundle("es");

Otwórz okno dialogowe Ustawienia / Preferencje ( Ctrl+ Alt+ S), a następnie kliknij opcję Edytor i kodowanie plików.

Następnie na dole wskażesz domyślne kodowanie plików właściwości. Wybierz typ kodowania.

Alternatywnie możesz użyć symboli Unicode zamiast tekstu w pakiecie zasobów (na przykład "ів"równa się \u0456\u0432)

W Javie 9 domyślny plik właściwości ładowania został zmieniony na UTF-8. https://docs.oracle.com/javase/9/intl/internationalization-enhancements-jdk-9.htm