Desenvolvendo Aplicativos que Utilizam JNDI

Referências a inícios de enterprise bean (EJB) e outros artefatos, como origens de dados, estão ligadas ao espaço de nomes do WebSphere Application Server. Esses objetos podem ser obtidos por meio de JNDI (Java™ Naming and Directory Interface). Antes de você poder executar qualquer operação de JNDI, será necessário obter um contexto inicial. Você pode utilizar o contexto inicial para consultar objetos ligados ao espaço de nomes.

Sobre Esta Tarefa

Nesses exemplos, o comportamento padrão dos recursos específicos da implementação do Contexto de JNDI do WebSphere Application Server é utilizado.

A implementação do contexto de JNDI do WebSphere Application Server inclui recursos especiais. O armazenamento em cache de JNDI melhora o desempenho de operações de consulta repetidas nos mesmos objetos. As opções de sintaxe de nome oferecem uma escolha entre sintaxes de nomes, uma otimizada para clientes JNDI típicos e uma otimizada para a interoperabilidade com os aplicativos CosNaming. Na maior parte das vezes, o comportamento padrão desses recursos é o comportamento de preferência. No entanto, às vezes é necessário modificar o comportamento para situações específicas.

O armazenamento em cache de JNDI e as opções de sintaxe de nome estão associados a uma instância javax.naming.InitialContext. Para selecionar opções para esses recursos, configure as propriedades reconhecidas pelo context factory inicial do WebSphere Application Server. Para configurar o armazenamento em cache de JNDI ou as propriedades da sintaxe de nome que estarão visíveis para o context factory inicial, faça o seguinte:

Procedimento

  1. Opcional: Configure os caches de JNDI

    O armazenamento em cache de JNDI pode melhorar muito o desempenho das operações de consulta de JNDI. Por padrão, o armazenamento em cache de JNDI está ativado. Na maioria das situações, esse padrão é o comportamento desejado. No entanto, em situações específicas, utilize as outras opções de cache de JNDI.

    Os objetos são armazenados em cache localmente quando são consultados. As consultas subseqüentes aos objetos em cache são resolvidas localmente. No entanto, o conteúdo do cache pode se tornar stale. Essa situação geralmente não é um problema, já que a maioria dos objetos consultados não são freqüentemente alterados. Se for necessário consultar objetos que são freqüentemente alterados, altere as opções de cache do JNDI.

    Os clientes JNDI podem utilizar várias propriedades para controlar o comportamento do cache.

    Você definir propriedades:
    • A partir da linha de comandos, inserindo o valor real da cadeia. Exemplo:
      java -Dcom.ibm.websphere.naming.jndicache.maxentrylife=1440
    • Em um arquivo jndi.properties, criando um arquivo denominado jndi.properties como um arquivo de texto com as definições de propriedades desejadas. Por exemplo:
      ...
      com.ibm.websphere.naming.jndicache.cacheobject=none
      ...

      Se você utilizar esta técnica, esteja ciente de que podem existir outras instâncias do arquivo jndi.properties no caminho de classe e podem conter configurações de propriedade conflitantes. As configurações de propriedade são determinadas pela ordem na qual o carregador de classes escolhe os arquivos jndi.properties. Não há forma de controlar a ordem que o carregador de classes utiliza para localizar arquivos no caminho de classe. O WebSphere Application Server inicialmente não contém ou cria nenhum arquivo jndi.properties que define a propriedade com.ibm.websphere.naming.jndicache.cacheobject.

    • Em um programa Java utilizando constantes Java PROPS.JNDI_CACHE*, definidas no arquivo com.ibm.websphere.naming.PROPS. As definições de constantes são as seguintes:
      public static final String JNDI_CACHE_OBJECT =
       "com.ibm.websphere.naming.jndicache.cacheobject";
      public static final String JNDI_CACHE_OBJECT_NONE      = "none";
      public static final String JNDI_CACHE_OBJECT_POPULATED = "populated";
      public static final String JNDI_CACHE_OBJECT_CLEARED   = "cleared";
      public static final String JNDI_CACHE_OBJECT_DEFAULT   =
       JNDI_CACHE_OBJECT_POPULATED;
      
      public static final String JNDI_CACHE_NAME =
       "com.ibm.websphere.naming.jndicache.cachename";
      public static final String JNDI_CACHE_NAME_DEFAULT = "providerURL";
      
      public static final String JNDI_CACHE_MAX_LIFE =
       "com.ibm.websphere.naming.jndicache.maxcachelife";
      public static final int    JNDI_CACHE_MAX_LIFE_DEFAULT = 0;
      
      public static final String JNDI_CACHE_MAX_ENTRY_LIFE =
       "com.ibm.websphere.naming.jndicache.maxentrylife";
      public static final int    JNDI_CACHE_MAX_ENTRY_LIFE_DEFAULT = 0;

      Para utilizar as propriedades anteriores em um programa Java, adicione a definição da propriedade a uma tabela hash e transmita-a ao construtor InitialContext da seguinte forma:

      java.util.Hashtable env = new java.util.Hashtable();
      ...
      
      // Desativar armazenamento em cache
      env.put(PROPS.JNDI_CACHE_OBJECT, PROPS.JNDI_CACHE_OBJECT_NONE); ...
      javax.naming.Context initialContext = new javax.naming.InitialContext(env);

    Os exemplos a seguir ilustram como você pode utilizar propriedades de cache JNDI para alcançar o comportamento de cache desejado. As propriedades do cache são efetivadas quando um objeto InitialContext é construído.

    Exemplo: Controlando o comportamento de cache JNDI de um programa

    import java.util.Hashtable;
    import javax.naming.InitialContext;
    import javax.naming.Context;
    import com.ibm.websphere.naming.PROPS;
    
    /*****
     O armazenamento em cache discutido nesta seção pertence ao factory de contexto inicial do WebSphere Application Server.
     Suponha que a propriedade, java.naming.factory.initial, seja configurada como
     "com.ibm.websphere.naming.WsnInitialContextFactory" como uma propriedade java.lang.System.
    *****/
    
    Hashtable env;
    Context ctx;
    
    // Para limpar uma cache:
    
    env = new Hashtable();
    env.put(PROPS.JNDI_CACHE_OBJECT, PROPS.JNDI_CACHE_OBJECT_CLEARED);
    ctx = new InitialContext(env);
    
    // Para definir a duração máxima da cache como 60 minutos:
    
    env = new Hashtable();
    env.put(PROPS.JNDI_CACHE_MAX_LIFE, "60");
    ctx = new InitialContext(env);
    
    // Para desativar a cache:
    
    env = new Hashtable();
    env.put(PROPS.JNDI_CACHE_OBJECT, PROPS.JNDI_CACHE_OBJECT_NONE);
    ctx = new InitialContext(env);
    
    // Para utilizar o armazenamento em cache e o não-armazenamento em cache:
    
    env = new Hashtable();
    env.put(PROPS.JNDI_CACHE_OBJECT, PROPS.JNDI_CACHE_OBJECT_POPULATED);
    ctx = new InitialContext(env);
    env.put(PROPS.JNDI_CACHE_OBJECT, PROPS.JNDI_CACHE_OBJECT_NONE);
    Context noCacheCtx = new InitialContext(env);
    
    Object o;
    
    // Utilize o armazenamento em cache para procurar o início, já que o início raramente deve ser alterado.
    o = ctx.lookup("com/mycom/MyEJBHome");
    // Refinar, etc. ...
    
    // Não utilize a cache se os dados são voláteis.
    o = noCacheCtx.lookup("com/mycom/VolatileObject");
    // ...

    Exemplo: Pesquisando uma sessão JavaMail com JNDI

    O exemplo a seguir mostra a consulta de um recurso JavaMail:

    // Get the initial context as shown previously
    ...
    Session session =
         (Session) initialContext.lookup("java:comp/env/mail/MailSession");
  2. Opcional: Especifique o nome da sintaxe

    A sintaxe INS foi desenvolvida para clientes JNDI que necessitem interoperar com aplicativos CORBA. Essa sintaxe permite que um cliente JNDI faça o mapeamento apropriado para e a partir do nome do CORBA. A sintaxe de INS é muito semelhante à sintaxe de JNDI com o caractere especial adicional ponto (.). Pontos são utilizados para delimitarem os campos id e kind num componente do nome. Um ponto é interpretado literalmente quando ele é com escape. Somente um ponto sem escape é permitido em um componente de nome. Um componente de nome com os campos id não vazio e kind vazio é representado apenas pelo valor do campo id e não deve ser encerrado por um ponto sem escape. Um componente de nome (campos id e kind vazio) é representado por um único ponto unescaped. Uma cadeia vazia não é uma representação válida de um componente de nome.

    A sintaxe de nomes JNDI é a sintaxe padrão e adequada para clientes JNDI típicos. Esta sintaxe inclui os seguintes caracteres especiais: barra (/) e barra invertida (\). Os componentes em um nome são delimitados por uma barra. A barra invertida é utilizada como o caractere de escape. Uma barra é interpretada literalmente se ela for com escape, ou seja, precedida por uma barra invertida. Da mesma forma, uma barra invertida é interpretada literalmente se ela for com escape.

    A maioria dos aplicativos do WebSphere utiliza JNDI para consultar objetos EJB e não precisa consultar objetos ligados por aplicativos CORBA. Portanto, a sintaxe de nome padrão para os nomes de JNDI é a mais conveniente. Se seu aplicativo precisar consultar objetos ligados por aplicativos CORBA, pode ser necessário alterar a sintaxe de nome para que todos os nomes CORBA CosNaming possam ser representados.

    Clientes de JNDI podem definir a sintaxe de nome definindo uma propriedade. A definição da propriedade é aplicada pelo depósito de informações do provedor de contexto inicial quando você instanciar um novo objeto java.naming.InitialContext. Os nomes especificados nas operações de JNDI no contexto inicial são analisados de acordo com a sintaxe de nome especificada.

    Você pode definir a propriedade:

    • Numa linha de comandos, insira valor real da cadeia. Por exemplo:
      java -Dcom.ibm.websphere.naming.name.syntax=ins
    • Crie um arquivo denominado jndi.properties como um arquivo de texto com as configurações de propriedade desejadas. Por exemplo:
      ...
      com.ibm.websphere.naming.name.syntax=ins
      ...

      Se você usar essa técnica, saiba que outras instâncias do arquivo jndi.properties podem existir no caminho de classe, e podem conter configurações de propriedade conflitantes. As configurações de propriedade são determinadas pela ordem na qual o carregador de classes escolhe os arquivos jndi.properties. Não há como controlar a ordem que o carregador de classes usa para localizar arquivos no caminho de classe. O WebSphere Application Server não inicialmente não contém ou cria arquivos jndi.properties que definem a propriedade com.ibm.websphere.naming.name.syntax.

    • Utilize as constantes Java PROPS.NAME_SYNTAX* definidas no arquivo com.ibm.websphere.naming.PROPS, num programa Java. As definições de constantes são as seguintes:
      public static final String NAME_SYNTAX =
          "com.ibm.websphere.naming.name.syntax";
      public static final String NAME_SYNTAX_JNDI = "jndi";
      public static final String NAME_SYNTAX_INS  = "ins";

      Para utilizar as propriedades anteriores em um programa Java, adicione a definição da propriedade a uma tabela hash e transmita-a ao construtor InitialContext da seguinte forma:

      java.util.Hashtable env = new java.util.Hashtable();
      ...
      env.put(PROPS.NAME_SYNTAX, PROPS.NAME_SYNTAX_INS);  // Set name syntax to INS
      ...
      javax.naming.Context initialContext = new javax.naming.InitialContext(env);

    Exemplo: Configurando a sintaxe usada para analisar sequências de nomes

    A propriedade de sintaxe de nomes pode ser transmitida para o construtor InitialContext através de seu parâmetro, nas propriedades do Sistema ou em um arquivo jndi.properties. O contexto inicial e todo contexto pesquisado nesse contexto inicial analisam cadeias de nomes com base na sintaxe especificada.

    O exemplo a seguir mostra como definir a sintaxe de nomes para fazer com que o contexto inicial analise cadeias de nomes de acordo com a sintaxe INS.

    ...
    import java.util.Hashtable;
    import javax.naming.Context;
    import javax.naming.InitialContext;
    import com.ibm.websphere.naming.PROPS;  // Constantes de nomenclatura do WebSphere
    ...
    Hashtable env = new Hashtable();
    env.put(Context.INITIAL_CONTEXT_FACTORY,
          "com.ibm.websphere.naming.WsnInitialContextFactory");
    env.put(Context.PROVIDER_URL, ...);
    env.put(PROPS.NAME_SYNTAX, PROPS.NAME_SYNTAX_INS);
    Context initialContext = new InitialContext(env);
    // O nome a seguir mapeia para um componente de nome CORBA da seguinte maneira:
    //    id = "a.name", kind = "in.INS.format"
    // O ponto sem escape é utilizado como o delimitador.
    // Os pontos com escape são interpretados literalmente.
    java.lang.Object o = initialContext.lookup("a\\.name.in\\.INS\\.format");
    ...

    A sintaxe de nomes INS exige que pontos (.) integrados em um nome, como in.INS.format, tenham escape utilizando uma barra invertida (\). Em uma Cadeia Java literal, um caractere de barra invertida (\) deverá ter escape com outro caractere de barra invertida (\\).

  3. Opcional: Desativar a normalização do nome do host

    Referências a nomes de host, endereços IP e localhost em URLs do provedor são geralmente normalizadas. O formato de um nome de host normalizado é a forma completa do nome do host. A normalização do nome do host melhora a eficiência do sistema porque permite que o mesmo cache JNDI seja usado para um determinado host de autoinicialização, independentemente do formato da referência na URL do provedor. Por exemplo, a normalização do nome do host permitirá que o mesmo cache JNDI seja usado para as referências myhost, myhost.mydomain.com e localhost, se todas essas referências referirem-se ao mesmo host.

    Porque os nomes do host normalizados são armazenados em cache, as normalizações subsequentes executam mais rapidamente. Em alguns ambientes em rede, os dados de consulta do nome de domínio mudam dinamicamente, fazendo com que os dados de normalização do nome do host armazenados em cache se tornem antigos. Em tais ambientes, pode ser necessário desativar a normalização do nome do host. Ao desativar a normalização do host, o nome do host e os endereços IP são usados no estado em que se encontram. Referências a host local geralmente resolvem para o endereço de autorretorno, 127.0.0.1.

    Clientes de JNDI podem desativar a normalização do nome do host definindo uma propriedade. A definição da propriedade é aplicada pelo depósito de informações do provedor de contexto inicial quando você instanciar um novo objeto java.naming.InitialContext.

    Use uma das seguintes técnicas para configurar essa propriedade:
    • É possível inserir o valor de cadeia real a partir de uma linha de comandos. Por exemplo:
      java -Dcom.ibm.websphere.naming.hostname.normalizer=...none...
    • É possível criar um arquivo denominado jndi.properties como um arquivo de texto com as configurações de propriedade desejadas. Por exemplo:
      ...
      com.ibm.websphere.naming.hostname.normalizer=...none...
      ...

      Se você usar essa técnica, saiba que outras instâncias do arquivo jndi.properties podem existir no caminho de classe, e podem conter configurações de propriedade conflitantes. As configurações de propriedade são determinadas pela ordem na qual o carregador de classes escolhe os arquivos jndi.properties. Não há como controlar a ordem que o carregador de classes usa para localizar arquivos no caminho de classe. O WebSphere Application Server não contém ou cria inicialmente nenhum arquivo jndi.properties que configura a propriedade com.ibm.websphere.naming.hostname.normalizer.

    • É possível usar as constantes Java PROPS.HOSTNAME_NORMALIZER* em um programa Java. Essas constantes Java são definidas no arquivo com.ibm.websphere.naming.PROPS. A seguir estão as definições de constante para especificar se você usará essa técnica:
      public static final String HOSTNAME_NORMALIZER =
          "com.ibm.websphere.naming.hostname.normalizer";
      public static final String HOSTNAME_NORMALIZER_NONE = "...none...;

      Para utilizar essas definições em um programa Java, inclua a definição da propriedade em uma hashtable e transmita-a ao construtor InitialContext:

      java.util.Hashtable env = new java.util.Hashtable();
      ...
      env.put(PROPS.HOSTNAME_NORMALIZER, PROPS.HOSTNAME_NORMALIZER_NONE);
          // Desativar a normalização do nome do host
      ...
      javax.naming.Context initialContext = new javax.naming.InitialContext(env);

    Exemplo: Desativando a normalização do nome do host

    É possível passar a propriedade normalizadora do nome do host para o construtor InitialContext por meio do parâmetro do construtor InitialContext no arquivo de propriedades do sistema, ou em um arquivo jndi.properties. O contexto inicial e todo o contexto futuro consultado nesse contexto inicial usam essa configuração de propriedade.

    O exemplo a seguir mostra como desativar a normalização de nome do host.

    ...
    import java.util.Hashtable;
    import javax.naming.Context;
    import javax.naming.InitialContext;
    import com.ibm.websphere.naming.PROPS;  // Constantes de nomenclatura do WebSphere
    ...
    Hashtable env = new Hashtable();
    env.put(Context.INITIAL_CONTEXT_FACTORY,
          "com.ibm.websphere.naming.WsnInitialContextFactory");
    env.put(Context.PROVIDER_URL, ...);
    env.put(PROPS.HOSTNAME_NORMALIZER, PROPS.HOSTNAME_NORMALIZER_NONE);
    Context initialContext = new InitialContext(env);
    java.lang.Object o = initialContext.lookup(...);
    ...

Ícone que indica o tipo de tópico Tópico de Tarefa



Ícone de registro de data e hora Última atualização: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=tnam_develop_naming
Nome do arquivo: tnam_develop_naming.html