Um entendimento geral de Jndi:
JNDI (interface de nomeação e diretório Java) Ele fornece um conjunto de interfaces que usam serviços de nomeação e diretório. Os usuários podem usar serviços de nomeação e diretório por meio dele. Assim como JDBC. O JNDI inclui duas partes: Serviço e serviço de diretório nomeados, onde o serviço de diretório contém objeto de diretório de diretório, que contém vários objetos de atributo. Fornece muitas operações em propriedades.
Serviços de nomeação e diretório:
Temos usado serviços de nomeação e diretório, como o sistema de arquivos do sistema operacional, que nos fornece funções como operações, consultas, adição e exclusão de arquivos. O serviço DNS une o URL e o endereço IP. A função mais importante dos sistemas de nomeação e diretório é ligar o nome e o objeto. Com base, ele também fornece mais funções, como pesquisa e pesquisa. Além disso, os objetos armazenados têm uma certa hierarquia. Usando esse serviço, podemos gerenciar e operar objetos de maneira mais eficaz.
O serviço de nomenclatura mapeia um nome para um objeto. O RMI Registry e o CORBA Naming Service são serviços de nomeação.
O serviço de diretório também armazena objetos, mas o serviço de diretório reconhece as propriedades relevantes desses objetos. Você pode usar as propriedades do projeto para procurar diretórios.
No início dos anos 90, o protocolo de acesso ao diretório leve (LightweightDiretoryAccessProtocol) foi desenvolvido como um protocolo de diretório padrão, e o JNDI conseguiu acessar o LDAP.
J2SE fornece 5 pacotes de extensão para JNDI:
Contexto: o contexto é um conjunto de ligações de nome a objeto, que podem ser entendidas como uma hierarquia ou diretório. Também pode incluir a próxima camada de subcontexto. Obter o contexto inicial ao usar serviços de nomeação e diretório é a entrada em toda a operação de namespace. No serviço de diretório está DirContext.
O JNDI (Java Naming and Directory Interface) é uma API projetada por aplicativos que fornece aos desenvolvedores uma interface comum e unificada para encontrar e acessar vários serviços nomeados e diretórios. O JDBC é construído na camada de abstração.
Os diretórios e serviços existentes que o JNDI pode acessar são:
DNS, XNAM, NOVELL Directory Service, LDAP (protocolo de acesso ao diretório leve), serviço de objeto CORBA, sistema de arquivos, Windows XP/2000/NT/ME/9X Registry, RMI, DSML V1 e V2, NIS.
Vantagens do JNDI:
Ele contém um grande número de serviços de nomeação e diretório, usando uma interface comum para acessar diferentes tipos de serviços; Pode ser conectado a vários serviços de nomeação ou diretório ao mesmo tempo; Ele estabelece associações lógicas, permitindo que os nomes sejam associados a objetos ou recursos Java sem precisar orientar o ID físico dos objetos ou recursos.
Pacote jndi:
Jndi vs. JDBC:
O JNDI fornece uma maneira unificada de encontrar e acessar serviços na rede. Ao especificar um nome de recurso que corresponda a um registro no banco de dados ou serviço de nomeação, ele retorna as informações necessárias para o estabelecimento de conexão do banco de dados.
Exemplo de código:
tente {context cntxt = new InitialContext (); DataSource ds = (DataSource) cntxt.lookup ("jdbc/dpt");} catch (namingException ne) {...} JNDI e JMS:
A comunicação de mensagens é um método usado por componentes ou aplicativos de software para se comunicar. O JMS é uma tecnologia Java que permite que os aplicativos criem, enviem, recebam e leiam mensagens.
Exemplo de código:
tente {Propriedades Env = new Properties (); InitialContext inictxt = new InitialContext (Env); TopicConnectionFactory ConnFactory = (TopicConnectionFactory) Inictxt.Lookup ("TtopicConnectionFactory"); ...} Catch (namingException ne) {...} Visite diretórios específicos: por exemplo, uma pessoa é um objeto e possui vários atributos, como o nome da pessoa, número de telefone, endereço de e -mail, código postal e outros atributos. Pelo método getAttributes ()
Atributo att = diretório.getAttributes (personname) .get ("email"); string email = (string) att.get (); Ao usar o JNDI, permitindo que os clientes usem o nome ou atributos do objeto para encontrar objetos:
Foxes = diretório.search ("o = wiz, c = nós", "sn = fox", controles); Exemplos de imprimoras de localização usando o JNDI para encontrar objetos como impressoras e bancos de dados:
Impressora impressora = (impressora) namespace.lookup (imprimername); impressora.print (document);
Procure namespaces:
NamingEnumeration List = Namespace.list ("O = widget, c = nós"); while (list.hasmore ()) {nameclasspair entrada = (nameclasspair) list.next (); display (entrada.getName (), entrada.getclassName ());}Exemplo de código: receba novamente o nome, o nome da classe e o objeto vinculado.
NamingEnumeration namenumlist = ctxt.ListBinding ("cntxtName"); ... while (namenumlist.hasmore ()) {binding bnd = (binding) namenumlist.next (); stringname = bnd.getname (); scrsnamname = bnEstMetname = scrsname = bnEstMetname (); (Algum objeto) bnd.getObject ();} Compreender os conceitos de serviços de nome e serviços de diretório ajudará a usar melhor o JNDI. O serviço de nome do serviço de nomenclatura define como associar um nome a um objeto e como encontrar um objeto através de um nome. Exemplos típicos são: DNS Associa os nomes de domínio com IP e os sistemas de arquivos associam nomes de arquivos com arquivos. No serviço de nome, os principais conceitos:
- Nomes (nomes), o nome do código do objeto real no sistema de nomes, como nomes de arquivos, nomes de domínio etc., ele será usado para encontrar o objeto associado. Sistemas diferentes terão especificações de nomeação diferentes, como o sistema de arquivos usa "/" para representar a hierarquia, enquanto o DNS usa ".".
- ligações, a associação de nomes e objetos reais.
- Referências e endereços. Quando um objeto não pode ser armazenado diretamente no sistema de nomes, uma referência deve ser usada para encontrar o objeto real através da referência. No sistema, o conteúdo da referência salva é chamado de endereço. Citações têm outro uso: no sistema de nomes, falta o conceito de chaves estrangeiras em bancos de dados relacionais. Usando referências, ele pode ser usado como uma alternativa às chaves estrangeiras.
-Contexto, é uma coleção de objetos de nome, fornecendo as operações principais para interagir com o sistema de nomes, como pesquisa, ligação e desativação. A relação entre o contexto da criança (subcontext) é semelhante à relação entre diretórios e subdiretos em um sistema de arquivos. O contexto da criança está contido em um contexto e está associado ao contexto da criança através de um nome no contexto dos pais.
- Sistemas de nomeação e namespaces. O sistema de nome é uma coleção do mesmo tipo de contexto e fornece serviços de nome. O espaço de nome é uma coleção de nomes no sistema de nomes, como nomes de arquivos e diretórios do sistema de arquivos.
Serviço de diretório de diretórios de diretório é uma extensão do serviço de nome. Além de associar nomes e objetos, ele também permite que os objetos contenham atributos. Os sistemas de diretórios geralmente organizam dados em uma hierarquia. Os principais conceitos em serviços de diretório:
- Atributos, que pertencem a um objeto de diretório, é um par (nome, valor) e o atributo pode ter vários valores.
- Diretórios e serviços de diretórios, os diretórios são coleções de objetos de diretório; Os serviços de diretório fornecem serviços relacionados ao diretório para criar, excluir e modificar as propriedades dos objetos armazenados no diretório.
- Pesquisas e filtros de pesquisa, a operação de obtenção de objetos de diretório é pesquisa; Os filtros são objetos semelhantes às condições de pesquisa.
Uso básico
² Registrando um provedor JNDI Antes de usar o JNDI, você precisa obter o provedor JNDI e registrá -lo no sistema. As propriedades do sistema relacionadas ao JNDI são definidas em javax.naming.context, propriedades comumente usadas:
- java.naming.factory.initial, o nome da classe usado pelo provedor de serviços para criar o inicialcontext.
- java.naming.provider.url, usado para configurar o URL inicial do InitialContext
-java.naming.Factory.Object, uma classe usada para criar mapas de nome para objeto, usados para nameclasspair e referências.
- java.naming.Factory.State, a classe usada para criar o estado JNDI. Para serviços de diretório, geralmente requer configurações de segurança e geralmente é usado:
- Java.naming.security.authentication, Tipo de segurança, três valores: nenhum, simples ou forte.
- java.naming.security.principal, informações de autenticação.
- java.naming.security.credentials, informações de certificação.
- java.naming.security.protocol, nome do protocolo de segurança.
Registre -se no System.setProperty. Se o programa não exibir as instruções, o Java procurará o arquivo jdni.properties no ClassPath para concluir o registro. JDNI.PROPERTIES EXEMPLO:
java.naming.factory.initial = com.codeline.db.mockinitialContextFactory
Serviço de conexão
Após o registro, você pode implementar a conexão de serviço. Para serviços de nome, comece com o InitialContext, os serviços de diretório Use InitialDirContext. Eles implementam contexto e dirContext, respectivamente. Essas duas interfaces correspondem às interfaces de serviços de nomes e serviços de diretório e também são as duas interfaces mais importantes do JNDI.
Connect Name Service:
System.setProperty (context.initial_context_factory, "com.sun.jndi.fscntext.fscrontextFactory"); InicialContext ctx = new InitialContext ();
Conecte aos serviços de diretório:
Hashtable Env = new Hashtable (); Env.put (context.initial_context_factory, "com.sun.jndi.ldap.ldapctxfactory"); Env.put (context.provider_url, "ldap: //myserver.com/"); Env.put (context.security_authentication, "simples"); // O nome de usuário necessário para fazer login no servidor LDAP é Env.put (context.security_principal, "ldapuser"); // Faça login no LDAP A senha exigida pelo servidor é Env.put (context.security_credentials, "mypassword"); InitialDirContext ctx = new InitialDirContext (Env);
Provedor de múltiplos serviços: se o aplicativo contiver vários provedores de serviços, será um pouco diferente ao conectar. Tome o serviço de nome como exemplo
Hashtable Env = new Hashtable (); Env.put (context.initial_context_factory, "com.sun.jndi.rmi.registry.registryContextFactory"); Env.put (context.provider_url, "rmi: //myserver.com: 1099"); // usa diferentes construtores InitialContext ctx = new InitialContext (Env);
Encontre objetos
Seja um serviço de nome ou um serviço de diretório, a pesquisa é usada para encontrar objetos. Além de usar a String como parâmetro, a pesquisa também pode usar a interface de nome como um parâmetro.
Cumprimentador cumprimentador = (cumprimentador) ctx.lookup ("sayhello"); Se você deseja obter todos os nomes de objetos no contexto, use LIS para retornar a lista NameClasspair. NameClasspair contém nome do objeto e nome da classe de objeto. Se você deseja obter a lista real de instâncias de objetos, use o ListBindings, que retorna a lista de ligação. A ligação é uma subclasse de nameclasspair, que contém instâncias de objetos.
- lista
NamingEnumeration List = ctx.list ("awt"); while (list.hasmore ()) {nameclasspair nc = (nameclasspair) list.next (); System.out.println (NC); } - ListBindings
Namingenumeration ligações = ctx.listbindings ("awt"); while (bindings.hasmore ()) {ligação bd = (ligação) bindings.Next (); System.out.println (bd.getName () + ":" + bd.getObject ()); }
Vinculação de objetos
- Adicione a ligação usando o bind
Frutas frutas = nova fruta ("laranja"); ctx.bind ("favorita", fruta); - Use Rebind para modificar a ligação
Frutas de fruta = nova fruta ("limão"); ctx.rebind ("favorito", fruta); - Use desbaste para remover ligações.
ctx.unbind ("favorito");
Renomeie o objeto
Use renomear para renomear um objeto no contexto
ctx.rename ("report.txt", "Old_report.txt");- As interfaces relacionadas à obtenção de atributos são atributos e atributos, ambos no pacote Javax.naming.directory. Você pode definir o atributo do objeto através do método GetAttributes de DirContext e, em seguida, usar o método de atributos Get para obter os atributos correspondentes e, finalmente, você pode obter o valor do atributo através do método Get of Attribute.
String dn = "uid = me, dc = mycompany, dc = com, ou = cliente, o = exampleApp"; Usuário de contexto = (contexto) ctx.lookup (dn); // obtenha todos os atributos atributos attrs = user.getAttributes (""); Teste de atributo = atts .get ("teste"); Objeto testValue = test.get ();No exemplo acima, todos os atributos do usuário são obtidos. No uso real, considerando o impacto da largura de banda de rede, você pode definir a lista de atributos a serem obtidos:
String reqd_attrs = new String [] {"Sobrenome", "Initiais", "Title", "RFC822Mailalias"}; Atributos attrs = user.getAttributes ("", reqd_attrs);
Encontre e filtra
Use o método de pesquisa para concluir.
public DirContext [] findUser (iniciais da string, sobrenome da string, string country, string telefone) {// Condições de construção Basicattributes search_attrs = new BasicAttributes (); search_attrs.put ("iniciais", iniciais); Search_attrs.put ("SN", incidente); Search_attrs.put ("C", país); if (telefone! = null) search_attrs.put ("PhoneNumber", telefone); Resultados de NamingEnumeration = Initial_ctx.search ("OU = cliente, o = ExampleApp", Search_attrs); LinkedList encontrado = new LinkedList (); while (resultados.hasmore ()) {searchResults sr = (searchResults) resultados.next (); Nome da sequência = sr.getName (); Objeto ctx = sr.getObject (); if ((ctx == NULL) ||! (CTX Instânciaof DirContext)) Found.add (Initial_ctx.Lookup (nome)); else found.add (ctx); } DIRCONTEXT [] ret_val = new DirContext [found.size ()]; encontrado.toArray (ret_val); retornar ret_val; }
Os principais métodos de filtragem da interface DirContext:
1. Use strings de filtro
String reqd_attrs = new String [] {"cn", "uid", "rfc822mailalias"}; Resultados de NamingEnumeration = Initial_ctx.search ("OU = cliente, o = ExampleApp", Search_attrs, reqd_attrs);
2. Use o SearchControls para obter mais controle
SearchControls Ctrls = new SearchControls (); Ctrls.setCountLimit (20); Ctrls.settimelimit (5000); ctrls.setsearchScope (searchcontrols.subtree_scope); Resultados de NamingEnumeration = Initial_ctx.Search ("CAT = Livros, OU = Produtos, O = ExampleApp", "Title =*Java*", Ctrls); Modificar propriedades
Isso é feito usando os métodos ModifyAttributes de DirContext e InitialDirContext. O chamado processo de modificação é realmente construir primeiro a lista de atributos a serem modificados e enviar usando o método acima. Quando uma propriedade contém vários valores, é necessário incluir os valores não modificados da propriedade; caso contrário, o servidor excluirá esses valores se não forem mais necessários.
public void updateAdDress (string dn, endereço da string, string country, string telefone) {Basicattributes mod_attrs = new BasicAttributes (); if (endereço! = null) mod_attrs.put ("endereço", endereço); if (country! = null) mod_attrs.put ("c", país); if (telefone! = null) mod_attrs.put ("PhoneNumber", telefone); if (mod_attrs.size ()! = 0) inicial_ctx.modifyAttributes (dn, dirContext.replace_attribute, mod_attrs); } Usando o ModificationItem, você também pode executar várias operações de modificação diferentes de uma só vez:
ModificationItem [] mod_items = new modificationItems [2]; Atributo email = new Basicattribute ("rfc822mailalias", new_email); ModificationItem email_mod = new modificationItem (DirContext.add_attribute, email); Atributo addr = new BasicAttribute ("endereço", endereço); ModificationItem addr_mod = new modificationItem (DirContext.replace_attribute, addr); mod_items [0] = email_mod; mod_items [1] = addr_mod; inicial_ctx.modifyAttributes (dn, mod_items); Criar um contexto
Use o método CreateSubContext para ser concluído.
BasicAttributes attrs = new BasicAttributes (); attrs.put ("iniciais", iniciais); attrs.put ("sn", incidente); attrs.put ("rfc822mailalias", email); if (endereço! = null) attrs.put ("endereço", endereço); if (país! = nulo) attrs.put ("c", país); if (telefone! = null) attrs.put ("foneNumber", telefone); inicial_ctx.createsubContext (dn, attrs);
Exclua o contexto
Use o método DestroySubContext para concluir.
inicial_ctx.destroysubContext (dn);
Exemplo
Aqui está outro exemplo.
Configure no Tomcat's conf/server.xml:
<Context Path = "/jndi"> <nome do recurso = "bean/mybeanfactory" auth = "container" type = "com.huawei.jndi.bean.mybean" factory = "org.apache.naming.factory.beanfactory" bar = "23"/> </context>
Um componente é declarado no tomcat acima, e você pode obter este componente no código:
tente {context initContext = new InitialContext (); Contexto Envctx = (context) initContext.lookup ("java: comp/Env"); Mybean bean = (mybean) Envctx.lookup ("Bean/mybeanFactory"); System.out.println (bean.getbar ()); } catch (Exceção e) {e.printStackTrace (); }Resumo: Configure o componente JNDI no Tomcat e, em seguida, obtenha os componentes equipados no código.
As classes de implementação do JNDI de cada contêiner da Web são diferentes. Por exemplo, em Jboss, a classe de provisão JNDI é org.jnp.interfaces.namingContextFactory, que é diferente do tomcat.
Desse ponto de vista, o papel do JNDI é semelhante ao da injeção de dependência da primavera. No entanto, através do JNDI, é possível obter componentes entre aplicativos e até mesmo em domínios. Os componentes configurados no servidor A podem ser obtidos através do JNDI em outro servidor B.
A primavera também fornece encapsulamento do JNDI, que é mais conveniente de usar. O seguinte é um exemplo.
<!-JNDI modelo-> <bean id = "jnditemplate"> <propriedade name = "ambiente"> <ports> <props key = "java.naming.factory.initial"> org.jnp.interfaces.namingContextFactory </prop> <prop key = "java.naming.provider.url"> 10.137.96.212:18199 </prop> <props key = "java.naming.factory.url.pkgs"> org.jnp.interfaces: org.jboss.naming </prop> </suports> </berg.jnpaces> </berg.jnp. id = "JMSConnectionFactory"> <Nome da propriedade = "jnditemplate" ref = "jnditemplate" /> <names name = "jndiname" value = "tópicoConnectionFactory" /> </i bean>
Declare primeiro o Jnditemplate, configure o endereço de destino e as classes de provisionamento de serviços JNDI. Em seguida, através do JndioBjectFactoryBean, você pode facilmente obter componentes JNDI e executar a conversão do tipo.