API für Internationalisierungskontext verwenden

EJB-Clientanwendungen, Servlets und Enterprise-Beans können Internationalisierungskontexte mit der API für Internationalisierungskontext programmintern abrufen und verwalten. Für Web-Service-Clientanwendungen verwenden Sie die API wie bei EJB-Clients und Enterprise-Beans, um den Internationalisierungskontext abzurufen und zu verwalten.

Vorbereitende Schritte

Die Pakete "java.util" und "com.ibm.websphere.i18n.context" enthalten alle Klassen, die zur Verwendung des Service zur Internationalisierung in einer EJB-Anwendung erforderlich sind.

Vorgehensweise

  1. Zugriff auf die API für Internationalisierungskontext

    Lösen Sie Referenzen auf die API für Internationalisierungskontext einmal während der Ausführung einer Anwendungskomponente in der Initialisierungsmethode dieser Komponente auf (z. B. in der Methode init von Servlets oder in der Methode SetXxxContext von Enterprise-Beans). Führen Sie für Web-Service-Clientprogramme die folgende Task aus, um während der Initialisierung eine Referenz auf die API für Internationalisierungskontext aufzulösen. Für Stateless-Session-Beans, die Web-Services unterstützen, wird die Referenz in der Methode setSessionContext aufgelöst.

  2. Auf Caller-Locales und -zeitzonen zugreifen

    Jeder ferne Aufruf einer Anwendungskomponente hat einen Aufrufinternationalisierungskontext, der dem Thread zugeordnet ist, der den Aufruf durchführt. Der Aufrufkontext wird vom Service zur Internationalisierung und von der Middleware an die Zieladresse einer Anforderung weitergegeben, z. B. an eine EJB-Geschäftsmethode oder eine Methode eines Servlet-Service. Diese Task gilt auch für Web-Service-Clientprogramme.

  3. Auf Aufruf-Locales und -zeitzonen zugreifen

    Jeder ferne Aufruf eines Servlet-Service oder einer EJB-Geschäftsmethode hat einen Aufrufinternationalisierungskontext, der dem Thread zugeordnet ist, der den Aufruf durchführt. Der Aufrufkontext ist der Internationalisierungskontext, in dem die Implementierungen von Servlet- und Geschäftsmethoden ausgeführt werden. Dieser Kontext wird vom Service zur Internationalisierung und von der Middleware an nachfolgende Aufrufe weitergegeben. Diese Task gilt auch für Web-Service-Clientprogramme.

Ergebnisse

Die erstellten Komponenten verwenden Application-Managed Internationalization (AMI). Weitere Informationen zu AMI finden Sie unter Internationalisierungskontext: Verwaltungsrichtlinien.

Beispiel

Jede unterstützte Anwendungskomponente verwendet die API für Internationalisierungskontext anders. Es werden Codebeispiele bereitgestellt, die die Verwendung der API in jedem Typ von Komponente veranschaulichen. Die unterschiedliche Verwendung der API sowie weitere Codierungshinweise sind in Kommentaren vor den entsprechenden Anweisungsblöcken angegeben.

Internationalisierungskontext in einem EJB-Clientprogramm verwalten: Das folgende Codebeispiel veranschaulicht, wie die API für Internationalisierungskontext in einem enthaltenen EJB-Clientprogramm oder Web-Service-Clientprogramm verwendet wird.

//------------------------------------------
// Grundbeispiel: J2EE-EJB-Client.
//------------------------------------------
package examples.basic;

//------------------------------------------
// SERVICE ZUR INTERNATIONALISIERUNG: Import
//------------------------------------------
import com.ibm.websphere.i18n.context.UserInternationalization;
import com.ibm.websphere.i18n.context.Internationalization;
import com.ibm.websphere.i18n.context.InvocationInternationalization;

import javax.naming.InitialContext;
import javax.naming.Context;
import javax.naming.NamingException;
import java.util.Locale;
import java.util.SimpleTimeZone;

public class EjbClient {

  public static void main(String args[]) {

    //--------------------------------------------------
    // SERVICE ZUR INTERNATIONALISIERUNG: API-Referenzen
    //--------------------------------------------------
    UserInternationalization userI18n = null;
    Internationalization callerI18n = null;
    InvocationInternationalization invocationI18n = null;
   
    //--------------------------------------------------
    // SERVICE ZUR INTERNATIONALISIERUNG: JNDI-Name
    //--------------------------------------------------
    final String UserI18NUrl =
        "java:comp/websphere/UserInternationalization";  

    //--------------------------------------------------
    // SERVICE ZUR INTERNATIONALISIERUNG: API auflösen
    //--------------------------------------------------
    try {
     Context initialContext = new InitialContext();    
     userI18n = (UserInternationalization)initialContext.lookup(
         UserI18NUrl);
     callerI18n = userI18n.getCallerInternationalization();
     invI18n = userI18n.getInvocationInternationalization ();
    } catch (NamingException ne) {
      log("Fehler: UserInternationalization kann nicht aufgelöst werden: Ausnahme: " + ne);
    } catch (IllegalStateException ise) {
      log("Fehler: UserInternationalization ist nicht verfügbar: " + ise);
    }
    ...

    //--------------------------------------------------------------------
    // SERVICE ZUR INTERNATIONALISIERUNG: Aufrufkontext setzen
    //
    // EJB-Clientprogramme in einem Container, die den Typ AMI
    // (Application-Managed Internationalization) haben, können
    // Aufrufkontextelemente setzen. Die folgenden Anweisungen
    // ordnen die angegebene Aufruf-Locale und Zeitzone dem
    // aktuellen Thread zu. Nachfolgende Aufrufe der fernen
    // Bean-Methode geben diese Kontextelemente weiter.
    //--------------------------------------------------------------------
    try {
      invocationI18n.setLocale(new Locale("fr", "FR", ""));
      invocationI18n.setTimeZone("ECT");
    } catch (IllegalStateException ise) {
      log("Beim Zugriff auf den Aufrufkontext ist eine Anomalie aufgetreten: " + ise );
    }
    ...

    //--------------------------------------------------------------------
    // SERVICE ZUR INTERNATIONALISIERUNG: Locale und Zeitzone abrufen.
    //
    // EJB-Clientprogramme in einem Container, die den Typ AMI haben,
    // können die Elemente des Caller- und Aufrufkontextes abrufen,
    // die dem aktuellen Thread zugeordnet sind.
    // Die nächsten vier Anweisungen geben die Aufruf-Locale und Zeitzone,
    // die oben zugeordnet wurden, und die Locale und Zeitzone des aufrufenden
    // Programms zurück, die intern vom Service zugeordnet wurden. Wenn ein
    // Caller-Kontextelement in einem Client in einem Container abgerufen wird,
    // wird das Standardelement der JVM verwendet.
    //--------------------------------------------------------------------
    Locale invocationLocale = null;
    SimpleTimeZone invocationTimeZone = null;
    Locale callerLocale = null;
    SimpleTimeZone callerTimeZone = null;
    try {
      invocationLocale = invocationI18n.getLocale();
      invocationTimeZone =                           
          (SimpleTimeZone)invocationI18n.getTimeZone();
      callerLocale = callerI18n.getLocale();
      callerTimeZone = SimpleTimeZone)callerI18n.getTimeZone();
    } catch (IllegalStateException ise) {
      log("Beim Zugriff auf den I18n-Kontext ist eine Anomalie aufgetreten: " + ise );
    }

    ...
  } // main

  ...
  void log(String s) {
    System.out.println (((s == null) ? "null" : s));
  }
} // EjbClient

Internationalisierungskontext in einem Servlet verwalten: Das folgende Codebeispiel veranschaulicht die Verwendung der API für Internationalisierungskontext in einem Servlet. Beachten Sie die Kommentare für die Methoden init und doPost.

...
//--------------------------------------------------------------------
// SERVICE ZUR INTERNATIONALISIERUNG: Import
//--------------------------------------------------------------------
import com.ibm.websphere.i18n.context.UserInternationalization;
import com.ibm.websphere.i18n.context.Internationalization;
import com.ibm.websphere.i18n.context.InvocationInternationalization;

import javax.naming.InitialContext;
import javax.naming.Context;
import javax.naming.NamingException;
import java.util.Locale;

public class J2eeServlet extends HttpServlet {

  ...
  //------------------------------------------------------------------
  // SERVICE ZUR INTERNATIONALISIERUNG: API-Referenzen
  //------------------------------------------------------------------
  protected UserInternationalization        userI18n = null;
  protected Internationalization i18n = null;
  protected InvocationInternationalization  invI18n  = null;

  //------------------------------------------------------------
  // SERVICE ZUR INTERNATIONALISIERUNG: JNDI-Name
  //------------------------------------------------------------
  public static final String UserI18NUrl = 
      "java:comp/websphere/UserInternationalization";  

  protected Locale callerLocale = null;
  protected Locale invocationLocale = null;

  /**
   * Servlet initialisieren.
   * Referenzen auf den JNDI-Ausgangskontext und
   * die API für Internationalisierungskontext auflösen.
   */
  public void init() throws ServletException {

    //------------------------------------------------------------------
    // SERVICE ZUR INTERNATIONALISIERUNG: API auflösen
    //
    // Servlets mit dem Typ CMI (Container-Managed Internationalization) haben
    // Lesezugriff auf die Elemente des Aufrufkontextes. Versuche, diese Elemente
    // zu setzen, lösen eine Ausnahme vom Typ IllegalStateException aus.
    //
    // Vorschlag: Alle Referenzen auf die API für Internationalisierungskontext
    // einmal während der Initialisierung zwischenspeichern und sie dann
    // während der gesamten Ausführung des Servlets verwenden.
    //------------------------------------------------------------------
    try {
      Context initialContext = new InitialContext();    
      userI18n = (UserInternationalization)initialContext.lookup(UserI18nUrl);
      callerI18n = userI18n.getCallerInternationalization();
      invI18n = userI18n.getInvocationInternationalization();
    } catch (NamingException ne) {
      throw new ServletException("UserInternationalization kann nicht aufgelöst werden" + ne);
    } catch (IllegalStateException ise) {
      throw new ServletException ("Fehler: UserInternationalization ist nicht
         verfügbar: " + ise);
    }
    ...
  } // init
  
  /**
   * Eingehende HTTP-GET-Anforderungen verarbeiten.
   * @param request Objekt, das die Anforderung für das Servlet enthält
   * @param response Objekt, das die Antwort des Servlets
   * enthält.
   */
  public void doGet(
      HttpServletRequest  request,
      HttpServletResponse response)
    throws ServletException, IOException {
            doPost(request, response);
  } // doGet

  /**
   * Eingehende HTTP-POST-Anforderungen verarbeiten.
   * @param request Objekt, das die Anforderung für das
   * Servlet enthält
   * @param response Objekt, das die Antwort des Servlets
   * Servlet enthält
   */
  	public void doPost(
      HttpServletRequest  request,
      HttpServletResponse response)
    throws ServletException, IOException {
        
    ...
    //--------------------------------------------------------------------
    // SERVICE ZUR INTERNATIONALISIERUNG: Caller-Kontext abrufen
    //
    // Der Internationalization Service extrahiert die accept-languages,
    // die in der HTTP-Anforderung weitergegeben werden, und ordnet
    // sie dem aktuellen Thread als Liste von Locales im Caller-Kontext zu.
    // Diese Locales sind in den Methoden des HTTP-Servlet-Service
    // zugänglich, die das Internationalisierungsobjekt des Callers verwenden.
    // 
    // Falls die eingehende HTTP-Anforderung keine accept-languages enthält,
    // ordnet der Service die Standard-Locale des Servers zu. Der Service
    // ordnet immer die Zeitzone GMT zu.
    //
    //--------------------------------------------------------------------
    try {
      callerLocale = callerI18n.getLocale();   // Caller-Locale
      // Der folgende Code ruft die Aufruf-Locale ab;
      // ist von den Internationalisierungsrichtlinie abhängig.
      invocationLocale = invI18n.getLocale();  // Aufruf-Locale
    } catch (IllegalStateException ise) {
      log("Beim Zugriff auf den Aufrufkontext ist eine Anomalie aufgetreten: " + ise );
    }
    // ANMERKUNG: Browser können accept-languages weitergeben, die zwar
    // einen Sprachencode, aber keinen Landescode enthalten, wie z. B. "fr"
    // für "Französisch, das in Frankreich gesprochen wird". Der folgende
    // Code stellt in solchen Fällen einen Standardlandescode bereit.
    if (callerLocale.getCountry().equals(""))
      callerLocale = AccInfoJBean.getCompleteLocale(callerLocale);
    
    // iLocale in JDK-Operationen verwenden, die Locale-abhängig sind, usw.
    ...
  } // doPost
  
  ...
  void log(String s) {
    System.out.println (((s == null) ? "null" : s));
  }
} // CLASS J2eeServlet

Internationalisierungskontext in einer Session-Bean verwalten: Dieses Codebeispiel veranschaulicht die Durchführung einer lokalisierten Operation, die den Service zur Internationalisierung verwendet, in einer Session-Bean oder Session-Bean mit Unterstützung von Web-Services.

...   
//------------------------------------------------------------
// SERVICE ZUR INTERNATIONALISIERUNG: Import
//------------------------------------------------------------
import com.ibm.websphere.i18n.context.UserInternationalization;
import com.ibm.websphere.i18n.context.Internationalization;
import com.ibm.websphere.i18n.context.InvocationInternationalization;

import javax.naming.InitialContext;
import javax.naming.Context;
import javax.naming.NamingException;
import java.util.Locale;

/**
 * Dies ist eine Klasse für eine kontextunabhängige (Stateless) Session Bean.
 */
public class J2EESessionBean implements SessionBean {

  //------------------------------------------------------------
  // SERVICE ZUR INTERNATIONALISIERUNG: API-Referenzen
  //------------------------------------------------------------
  protected UserInternationalization        userI18n = null;
  protected InvocationInternationalization  invI18n  = null;

  //------------------------------------------------------------
  // SERVICE ZUR INTERNATIONALISIERUNG: JNDI-Name
  //------------------------------------------------------------
  public static final String UserI18NUrl = 
      "java:comp/websphere/UserInternationalization";  
  ...
  
  /**
   * Referenz auf das richtigen Internationalization-Interface
   * in dieser Methode abrufen.
   * @param ctx javax.ejb.SessionContext
   */
  public void setSessionContext(javax.ejb.SessionContext ctx) {

    //------------------------------------------------------------
    // SERVICE ZUR INTERNATIONALISIERUNG: API auflösen
    //------------------------------------------------------------
    try {
      Context initialContext = new InitialContext();    
      userI18n = (UserInternationalization)initialContext.lookup(
          UserI18NUrl);
      invI18n = userI18n.getInvocationInternationalization();
    } catch (NamingException ne) {
      log("Fehler: UserInternationalization kann nicht aufgelöst werden: Ausnahme: " + ne);
        
    } catch (IllegalStateException ise) {
      log("Fehler: UserInternationalization ist nicht verfügbar: " + ise);
    }
  } // setSessionContext 

 /**
  * Ressourcenpaket mit I18n-Service einrichten
  */
  public void setResourceBundle()
  {
    Locale invLocale   = null;

    //------------------------------------------------------------
    // SERVICE ZUR INTERNATIONALISIERUNG: Aufrufkontext abrufen
    //------------------------------------------------------------
    try {
      invLocale = invI18n.getLocale();
    } catch (IllegalStateException ise) {
      log ("Beim Zugriff auf den Aufrufkontext ist eine Anomalie aufgetreten: " + ise );
    }
    try {
      Resources.setResourceBundle(invLocale);
      // Klasse Resources stellt Unterstützung für den Abruf von Nachrichten aus
      // den Ressourcenpaketen bereit. Siehe Quellcode des Beispiels "Currency Exchange".
    } catch (Exception e)  {
      log("Fehler: Beim Definieren des Ressourcenpakets ist eine Ausnahme eingetreten: " + e);
    }
  } // setResourceBundle

  /**
   * Nachrichtenschlüssel zum Abrufen der lokalisierten Texte übergeben
   * @return java.lang.String []
   * @param key java.lang.String []
   */
  public String[] getMsgs(String[] key) {
    setResourceBundle();
    return Resources.getMsgs(key);    
  }

  ...
  void log(String s) {
    System.out.println(((s == null) ? ";null" : s));
  }
} // CLASS J2EESessionBean

Internationalisierungskontext in einem SOAP-Header darstellen: Dieses Codebeispiel veranschaulicht, wie Internationalisierungskontext im SOAP-Header einer Web-Service-Anforderung dargestellt wird.

<InternationalizationContext>
   <Locales>
      <Locale>
         <LanguageCode>ja</LanguageCode>
         <CountryCode>JP</CountryCode>
         <VariantCode>Nihonbushi</VariantCode>
      </Locale>
      <Locale>
         <LanguageCode>fr</LanguageCode>
         <CountryCode>FR</CountryCode>
      </Locale>
      <Locale>
         <LanguageCode>en</LanguageCode>
         <CountryCode>US</CountryCode>
      </Locale>
   </Locales>
   <TimeZoneID>JST</TimeZoneID>
</InternationalizationContext>
Diese Darstellung ist für das folgende Schema gültig:
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <xsd:element name="InternationalizationContext" 
                 type="InternationalizationContextType"> 
    </xsd:element>

    <xsd:complexType name="InternationalizationContextType">
        <xsd:sequence>
            <xsd:element name="Locales" 
                         type="LocalesType">
            </xsd:element>
            <xsd:element name="TimeZoneID" 
                         type="xsd:string">
            </xsd:element>
        </xsd:sequence>
    </xsd:complexType>

    <xsd:complexType name="LocalesType">
        <xsd:sequence>
            <xsd:element name="Locale" 
                         type="LocaleType" 
                         minOccurs="0"
                         maxOccurs="unbounded"> 
            </xsd:element>
        </xsd:sequence>
    </xsd:complexType>

    <xsd:complexType name="LocaleType"> 
        <xsd:sequence>
            <xsd:element name="LanguageCode" 
                         type="xsd:string" 
                         minOccurs="0"
                         maxOccurs="1"> 
            </xsd:element>
            <xsd:element name="CountryCode" 
                         type="xsd:string" 
                         minOccurs="0"
                         maxOccurs="1"> 
            </xsd:element>
            <xsd:element name="VariantCode" 
                         type="xsd:string" 
                         minOccurs="0"
                         maxOccurs="1"> 
            </xsd:element>
         </xsd:sequence>
    </xsd:complexType>
    
</xsd:schema> 

Symbol, das den Typ des Artikels anzeigt. Taskartikel



Symbol für Zeitmarke Letzte Aktualisierung: 25.05.2016
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=tin_manageapi
Dateiname:tin_manageapi.html