Java chama Web Service. Quando você entrar em contato pela primeira vez, você acha que é um pesadelo, especialmente sem uma implementação padrão unificada. Comparado à implementação do WebService que pode ser concluída em algumas etapas do .NET, é realmente triste ver a implementação do Java. Mas mesmo se estivermos tristes, ainda temos que concluí -lo. Java também tem muitas boas implementações, como XFire, Jersey, CXF. Aqui vamos dar uma olhada na implementação do XFire juntos.
1) Primeiro de tudo, é claro que tenho que sair da bolsa, e essa pessoa comum sabe disso. http://xfire.codehaus.org/download Você pode ir aqui, você pode ir a toda ou distribuição. Mas é melhor dar muitos problemas estranhos para perder a confiança.
O que devo fazer se tirar a bolsa? Coloque no projeto. Parece bobagem, mas muitas pessoas simplesmente não sabem o que fazer.
Para construir um novo projeto, comparo -o com o XFireWebService, que é obviamente um projeto da Web aqui.
Eu coloquei todos os seus pacotes aqui. Afinal, quando escrevemos exemplos, não há necessidade de ser exigente. Clique nele casualmente. Se você quiser ver as informações de exceção, poderá adicioná -las lentamente. É fácil eliminar erros no futuro, mas não faremos isso aqui. Afinal, não há nada feio na falta de qualquer tipo de exceção, e você pode eliminá -las você mesmo.
2) Vamos primeiro entender a diferença entre o XFire e outras estruturas do WebService. A maior diferença é que ele requer uma interface e, se você precisar usar o XFire para chamar o serviço da web correspondente, deve saber a definição da interface. Eu sinto que há um pouco de limitação aqui. Mas, além disso, é bastante conveniente chamar o WebService, assim como chamar métodos locais. Vamos dar uma olhada no exemplo diretamente:
Primeiro de tudo, a interface mais importante:
interface pública IreaderService {public Reader GetReader (nome da string, senha da string); Lista pública <Leoter> getReaders (); } Existe uma interface, é claro que deve haver uma classe de implementação, caso contrário, a interface não terá significado. classe pública ReaderService implementa o IRADERSERVICE {public Reader GetReader (nome da string, string senha) {return New Reader (nome, senha); } Lista pública <LeerDer> getReaders () {list <erader> leitorList = new ArrayList <erader> (); leitorlist.add (novo leitor ("shun1", "123")); leitorlist.add (novo leitor ("shun2", "123")); Retornar Readerlist; }} Dê uma olhada também nas aulas de Javabean e Reader:
public class Reader {private estático final serialversionuid = 1L; nome de string privado; senha de sequência privada; public reader () {} public leitor (nome da string, senha da string) {this.name = name; this.password = senha; } // Método Get/Set omite public String tostring () {return "Name:"+Name+", senha:"+senha; }}Observe que nossa aula de leitor aqui implementa a interface serializável, por quê? Aqui, antes de tudo, precisamos entender o princípio do Web Service. Para Java, se precisarmos fazer upload de objetos na Internet, muitas pessoas pensarão na serialização. A propósito, isso é serialização, porque precisamos passar pelo leitor como um parâmetro. Isso precisa ser implementado à força na versão anterior, caso contrário, um erro será relatado. No entanto, a versão mais recente (de fato, a mais recente também é de 2007, porque o XFire parou de se desenvolver e foi mesclado em um projeto CXF pelo Apache. Vamos falar sobre isso mais tarde) não é mais necessário. Quanto a como implementá -lo, não o investigaremos em profundidade aqui por enquanto, porque ele foi fundido no CXF. Se quisermos aprender em profundidade, deve ser melhor aprender CXF.
3) Depois de concluirmos a interface acima e a escrita de Javabean, muitas pessoas perguntarão, vejo que muitos serviços da web terão arquivos WSDL, então como você conseguiu? Antes de falar sobre isso, vamos discutir o que é o WSDL. Talvez muitas empresas forneçam interfaces que são apenas endereços HTTP, retornando formatos XML, assim como os nossos. Isso tem uma vantagem e uma desvantagem. A vantagem é que nosso desenvolvimento é menos difícil, enquanto a desvantagem é que precisamos fornecer aos usuários vários arquivos de explicação. O que significa cada tag XML retornada? Isso não é nada, mas é apenas irritante. Quanto ao serviço da web, a desvantagem é que desenvolvemos um pouco mais de coisas, e a vantagem é que não precisamos escrever tantos arquivos de explicação, porque há uma explicação unificada chamada WSDL. Este é o documento de explicação do WebService, que é unificado e o mesmo, independentemente do idioma, portanto, não há problema que ninguém possa entender.
E aqui, quando implantamos o XFire, ele pode nos ajudar a gerar arquivos WSDL.
O problema é como implantá -lo, isso é realmente simples. Criamos uma nova meta-Inf no diretório SRC e, em seguida, criamos uma pasta Xfire nele e criamos o arquivo Services.xml. A estrutura subsequente é a seguinte:
Algumas pessoas podem perguntar por que precisamos construí -lo no diretório SRC. De fato, não é uma construção prescrita aqui, mas porque precisamos pedir às ferramentas de desenvolvimento para nos ajudar a implantar esses arquivos, por isso, se o colocarmos aqui, o Eclipse pode nos ajudar a implantá -lo no Tomcat ou em outros contêineres. Observe que o nível da pasta em que este arquivo está localizado é corrigido e não pode ser modificado.
Vamos dar uma olhada no Service.xml diretamente:
<? xml versão = "1.0" coding = "utf-8"?> <beans xmlns = "http://xfire.codehaus.org/config/1.0"> <vérices> <!-o nome do webserviceQ, você precisa especificar isso quando chama <nome> <name> <! -> <NameSpace> http: // test/helloservice </namespace> <!-classe interface-> <Verticeclass> com.xfire.servlet.ireaderService </serveClass> <!-Classe de implementação-> implementationclass> com.xfire.Servlet.ReaderStice </implementation-> implementation> com.xfire.sertleT.
Geralmente, é bom olhar para os comentários.
4) Muitas pessoas pensam que isso é suficiente. Não, ainda não funcionou. Se você especificar isso, como os outros podem visitá -lo? Como encaminhar a solicitação correspondente ao XFire e deixá -la processá -la. Precisamos modificar o web.xml novamente.
Após a modificação, o seguinte é:
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns: web = "http://java.sun.com/xml/ns/javaee" xmlns: web = "http://java.sun.com/xml/ns/javaee/web-app_2.xsd" xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaeee/web-app_3_0.xsd" id = "webApp_id" = "3.0"> <ervertlet> <Verlet-class-class> org.codehaus.xfire.transport.http.xfireconfigurablesServlet </servlet-class> </servlet> <sirtlet-mapping> <Vertlet-name> xfireServlet </servlet-name> <url--Tattern>//*- </url--pattlear
De fato, está apenas adicionando um servlet e o mapeamento correspondente. Em seguida, entramos diretamente no navegador:
http: // localhost: 8080/xfirewebService/Services/ReaderService? WSDL
Podemos ver:
O que é exibido aqui é o WSDL, que exibirá o método que definimos e o tipo retornado. Há uma explicação do WSDL mais tarde.
5) Depois de concluir as quatro etapas acima, concluímos a implantação do serviço da web. Outros podem chamar o serviço da web correspondente para acessar nossos métodos. Vamos usar o cliente fornecido pelo XFire para acessar o serviço do site que acabamos de publicar:
classe pública ReaderClient {public static void main (string [] args) {// aqui é criar um serviço, e uma classe de interface precisa ser transmitida, porque devemos chamar o serviço de interface correspondente SRCMODel = new ObjecjustServiceFactory (). Create (iReaderService.class); // Fábrica de agentes, aqui está para criar a classe de interface correspondente mais tarde xfireproxyfactory fábrica = new XFireProxyFactory (xfirefactory.newInstance (). Getxfire ()); // Endereço do Web Service, nenhum WSDL precisa ser adicionado à String ReaderServiceurl = "http: // localhost: 8080/xfirewebService/Services/ReaderService"; tente {// use a fábrica para retornar a classe de interface correspondente IRADERERSERVICE READERSERVICE = (IRADERSERVICE) Factory.Create (srcmodel, ReaderServiceUrl); Leitor leitor = leitorservice.getReader ("shun", "123"); System.out.println (leitor); } catch (malformEdurlexception e) {e.printStackTrace (); }}} Dessa forma, vemos que a saída é:
Análise da estrutura de arquivos WSDL
WSDL (SERVIÇOS DE WEB Descrição Idioma, Serviço da Web Descrição do idioma) é um aplicativo XML que define uma descrição do serviço da Web como um conjunto de pontos de acesso ao serviço através dos quais os clientes podem acessar serviços que contêm informações de informações ou procedimentos de documentos (semelhantes às chamadas de procedimento remoto). O WSDL primeiro abstrairá a operação de acesso e a mensagem de solicitação/resposta usada durante o acesso e, em seguida, o vincula a um protocolo de transporte específico e formato de mensagem para definir o ponto de acesso de serviço implantado específico. Os pontos de acesso ao serviço para implantações específicas relacionadas tornam -se serviços abstratos da Web através da combinação. Este artigo explicará a estrutura do documento WSDL em detalhes e analisará o papel de cada elemento.
1: Definição WSDL
O WSDL é um documento usado para descrever com precisão os Serviços da Web, e um documento WSDL é um documento XML que segue o padrão XML WSDL. O documento WSDL define um serviço da Web como uma coleção de pontos de acesso a serviços ou portas. No WSDL, como a definição abstrata de pontos de acesso e mensagens de acesso ao serviço foi separada da implantação específica de serviço ou da ligação do formato de dados, a definição abstrata pode ser usada novamente: a mensagem refere -se a uma descrição abstrata dos dados trocados; e o tipo de porta refere -se a uma coleção abstrata de operações. Protocolos específicos e especificações de formato de dados para tipos de porta específicos constituem uma ligação que pode ser reutilizada. Associando um endereço de acesso à Web a uma ligação reutilizável, uma porta pode ser definida e uma coleção de portas é definida como um serviço.
Um documento WSDL geralmente contém 7 elementos importantes, ou seja, tipos, importação, mensagem, porttype, operação, ligação e elementos de serviço. Esses elementos são aninhados no elemento de definições, que é o elemento raiz do documento WSDL. A próxima parte do artigo introduzirá a estrutura básica do WSDL em detalhes.
2: Estrutura básica do WSDL-Overview
Conforme descrito no final da primeira parte, um documento WSDL básico contém 7 elementos importantes. A seguir, apresentará esses elementos e suas funções.
O documento WSDL usa os seguintes elementos na definição de um serviço da Web:
・ Tipos - Um contêiner definido por um tipo de dados, que usa um determinado sistema de tipos (geralmente o sistema de tipos no esquema XML).
・ Mensagem - Abstract Type Definição de estruturas de dados para mensagens de comunicação. Use os tipos definidos pelos tipos para definir a estrutura de dados de toda a mensagem.
・ Operação - Uma descrição abstrata das operações suportadas no serviço. Geralmente, uma única operação descreve um par de mensagens de solicitação/resposta que acessa a entrada.
・ PortType - Uma coleção abstrata de operações suportadas por um certo tipo de ponto de entrada de acesso, que pode ser suportado por um ou mais pontos de acesso ao serviço.
・ Ligação - Ligação de protocolos específicos e especificações de formato de dados para tipos de porta específicos.
・ Porta - definida como um único ponto de acesso ao serviço que combina a ligação do formato de protocolo/dados com endereços específicos de acesso à Web.
・ Serviço- Uma coleção de pontos de acesso ao serviço relacionados.
O esquema XML do WSDL pode ser referido como o seguinte URL: http://schemas.xmlsoap.org/wsdl/
Três: Estrutura básica da WSDL-descrição detalhada
Esta seção descreverá em detalhes o papel de cada elemento do documento WSDL por meio de um exemplo. O exemplo a seguir é o conteúdo de um documento WSDL simples. Para a geração deste documento, consulte meu outro artigo: Exemplo de Desenvolvimento do Xfire--Lowerlorld.
Um documento WSDL de serviço da web simples que suporta uma operação exclusiva chamada Sayhello, que é implementada executando o protocolo SOAP no HTTP. A solicitação aceita um nome de string e retorna uma string simples após o processamento. A documentação é a seguinte:
<? xml versão = "1.0" coding = "utf-8"?> <wsdl: definições TargetNamesPace = "http: //com.liuxiang.xfiretemo/helloservice" xmlns: tns = "http: //com.liuxiang.xfiredemoMoMoMoMoMoMoMoMoMoMoMoMoMoMoMo. xmlns: wsdlsoap = "http://schemas.xmlsoap.org/wsdl/soap/" xmlns: SOAP12 = "http://www.w.org/2003/05/soap-envelope" xmlns: xsd = "http://www.w3.org/2001/xmlschema" xmlns: sabonenc11 = "http://schemas.xmlsoap.org/soap/encoding/" xmlns: SOAPENC12 = "http://www.w3.org/2003/05/soap-encoding" xmlns: Soap11 = "http://schemas.xmlsoap.org/soap/envelope/" xmlns: wsdl = "http://schemas.xmlsoap.org/wsdl/"> <wsdl: types> <xsd: schema xmlns: xsd = "http://www.ww3.org/2001/xmlschema" targetNamespace="http://com.liuxiang.xfireDemo/HelloService"> <xsd:element name="sayHello"> <xsd:complexType> <xsd:sequence> <xsd:element maxOccurs="1" minOccurs="1" name="name" nillable="true" type="xsd:string" /> </xsd: sequence> </xsd: complextype> </xsd: element> <xsd: elemento name = "sayhellorSponse"> <xsd: complextype> <xsd: sequence> <xsd: elemento maxoccurs = "1" Minccurs = "1" name = "out" nlable = "nable =" Truening "") </xsd: complexType> </xsd: element> </xsd: schema> </wsdl: types> <wsdl: message name = "sayhellorSponse"> <wsdl: nome de parques = "parâmetros" <lement = "tns: SayhellLoSPonse"/> </wsdl: <wsdl: parte name = "parâmetros" element = "tns: sayhello" /> < /wsdl: message> <wsdl: porttype name = "helloserviceportType"> <wsdl: name "sayhello"> <wsdl: names de inserção = sayhelloreestro " name = "SayHellorSponse" message = "TNS: SayHellResponse"/> </WSDL: Operação> </wsdl: PortType> <wsdl: Nome de ligação = "HelloserviceHttpBinding" Type = "TNS: HeloservicePrtype"> <WSDLOAP " transport = "http://schemas.xmlsoap.org/soap/http"/> <wsdlsoap: operação name = "sayhello"> <wsdlsoap: operação SOAPAction = ""/> <WSDLSOAP: Operação Soapaction = "/> <wsdlsoap: bodying =" <wsdlsoap: body use = "literal"/> </wsdl: output> </wsdl: operação> </wsdl: encadernação> <wsdl: nome do serviço = "helloservice"> <wsdl: port name = "helloservicehtpport" binding = "tnns: hellSerticeHt =" Location = "http: // localhost: 8080/xfire/Services/Helloservice"/> </wsdl: port> </wsdl: Service> </wsdl: Definições>
O elemento Type usa o idioma do esquema XML para declarar tipos e elementos complexos de dados usados em outras partes do documento WSDL;
O elemento de importação é semelhante ao elemento de importação em um documento de esquema XML e é usado para importar definições WSDL de outros documentos WSDL;
O elemento da mensagem descreve a carga útil de uma mensagem usando o tipo interno, tipo complexo ou elemento do esquema XML definido no elemento de tipo do documento WSDL ou definido no documento WSDL externo referenciado pelo elemento de importação;
O elemento PortType e o elemento de operação descrevem a interface do serviço da Web e definem seus métodos. O elemento PortType e o elemento de operação são semelhantes à declaração do método definida na interface Java. O elemento de operação usa um ou mais tipos de mensagens para definir a carga útil de sua entrada e saída;
O elemento de ligação atribui o elemento PortType e o elemento de operação a um protocolo especial e estilo de codificação;
O elemento de serviço é responsável por atribuir o endereço da Internet a uma ligação específica;
1. Elementos de definições
O elemento raiz de todos os documentos WSDL é um elemento de definições. Esse elemento encapsula o documento inteiro enquanto fornece um documento WSDL através de seu nome. Esse elemento não tem outra função, exceto o fornecimento de um espaço para nome, portanto não será descrito em detalhes.
O código a seguir é a estrutura de um elemento de definições:
<wsdl: definições TargetNamespace = "http: //com.liuxiang.xfireteemo/helloservice" xmlns: tns = "http: //com.liuxiang.xfiredemo/helloservice" xmlns: wsdlsoap = "http://schemas.xmlsoap.org/wsdl/soap/" xmlns: SOAP12 = "http://www.w.org/2003/05/soap-envelope" xmlns: xsd = "http://www.w3.org/2001/xmlschema" xmlns: sabonenc11 = "http://schemas.xmlsoap.org/soap/encoding/" xmlns: SOAPENC12 = "http://www.w3.org/2003/05/soap-encoding" xmlns: Soap11 = "http://schemas.xmlsoap.org/soap/envelope/" xmlns: wsdl = "http://schemas.xmlsoap.org/wsdl/"> </wsdl: definições>
2. Tipos de elementos
O WSDL adota os tipos de esquema W3C XML como seu sistema de tipo básico. O elemento Tipe é usado como um contêiner para definir vários tipos de dados não descritos nos tipos internos de esquema XML. Ao declarar a carga útil da peça da mensagem, a definição da mensagem usa os tipos e elementos de dados definidos no elemento Tipo. Tipes definições neste documento WSDL:
<wsd:types> <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" attributeFormDefault="qualified" elementFormDefault="qualified" targetNamespace="http://com.liuxiang.xfireDemo/HelloService"> <xsd:element name = "SayHello"> <xsd: complexType> <xsd: sequence> <xsd: elemento maxoccurs = "1" mincoccurs = "1" name = "name" nillable = "true" type = "xsd: string"/> </xsd: sequência> </xsd: complexType> </xsd ": <xsd: complextype> <xsd: sequence> <xsd: elemento maxoccurs = "1" mincocurs = "1" name = "out" nillable = "true" type = "xsd: string"/> </xsd: sequence> </xsd: complextype> </xsd: ele.
O exposto acima é a parte da definição de dados, que define dois elementos, um é Sayhello e o outro é o SayHellResponse:
DizHello: define um tipo complexo que contém apenas uma string simples, usada para descrever a parte recebida da operação no futuro;
Diz que a resposta: define um tipo complexo que contém apenas uma string simples e o valor de retorno usado para descrever a operação no futuro;
3. Elementos de importação
O elemento de importação permite o uso dos elementos de definição no espaço de nome especificado em outros documentos WSDL no documento WSDL atual. O elemento de importação não é usado neste exemplo. Essa função geralmente é muito eficaz quando os usuários desejam modularizar os documentos WSDL.
O formato de importação é o seguinte:
<wsdl: importar namespace = "http://xxx.xxx.xxx/xxx/xxx" location = "http://xxx.xxx.xxx/xxx/xxx.wsdl"/>
Deve haver um atributo de espaço para nome e um atributo de localização:
Atributo do espaço para nome: o valor deve corresponder ao TargetNamespace declarado no documento WSDL que está sendo importado;
Atributo da localização: deve apontar para um documento WSDL real e o documento não pode estar vazio.
4. Elementos da mensagem
O elemento da mensagem descreve a carga útil de um serviço da web usando mensagens. O elemento da mensagem pode descrever a carga útil da saída ou de aceitação da mensagem; Ele também pode descrever o conteúdo do cabeçalho do arquivo SOAP e o elemento de detalhe de erro. A maneira como o elemento da mensagem é definido depende do uso de mensagens de estilo RPC ou estilo de documento. Na definição do elemento de mensagem deste artigo, este documento usa mensagens de estilo de documentos:
<wsdl: mensagem name = "sayhellorSponse"> <wsdl: nome name = "parâmetros" element = "tns: sayhellorSponse" /> < /wsdl: message> <wsdl: name da mensagem = "sayhelloreQuest"> <wsdl: nome /"parameters"
Esta parte é uma definição abstrata do formato da mensagem: Duas mensagens SayHellResponse e SayHelloreQuest são definidas:
DizHelloreQuest: o formato de mensagem de solicitação da operação Sayhello, consistindo em um fragmento de mensagem, denominado parâmetros, e o elemento é o elemento no tipo que definimos anteriormente;
SayHellResponse: O formato da mensagem de resposta da operação Sayhello é composto por um fragmento de mensagem, denominado parâmetros, e o elemento é o elemento nos tipos que definimos anteriormente;
Se você usar mensagens no estilo RPC, só precisará modificar o elemento elemento no documento para digitar.
5. Elemento PortType
O elemento PortType define a interface abstrata do serviço da web. Essa interface é um pouco semelhante às interfaces Java, as quais definem um tipo e método abstrato, e nenhuma implementação é definida. No WSDL, o elemento PortType é implementado por elementos de ligação e serviço, que são usados para ilustrar o protocolo da Internet, o esquema de codificação e o endereço da Internet usado pela implementação do serviço da Web.
Várias operações podem ser definidas em um PortType e uma operação pode ser considerada um método. A definição do documento WSDL neste artigo:
<wsdl: porttype name = "helloserviceporttype"> <wsdl: operação name = "sayhello"> <wsdl: entrada de entrada = "sayhelloreQuest" message = "tns: sayhelloreQuest" /> <wsdl: names de saída = "SayHellEssonsense" </wsdl: PortType>
Porttype define o tipo do modo de chamada do serviço. Ele contém uma operação diz o métodohello, que contém entrada e saída para indicar que a operação é um modo de solicitação/resposta. A mensagem de solicitação é a SayHelloreQuest definida anteriormente, e a mensagem de resposta é a SayHellResponse definida anteriormente. A entrada representa a carga útil entregue ao serviço da web e a mensagem de saída representa a carga útil entregue ao cliente.
6. Ligação
O elemento de ligação mapeia um porttype abstrato para um conjunto de protocolos específicos (SOAO e HTTP), estilos de mensagens e estilos de codificação. Geralmente, os elementos de ligação são usados juntamente com os elementos proprietários do protocolo. Exemplos neste artigo:
<wsdl: name de ligação = "helloserviceHttpBinding" type = "tns: helloservicePortype"> <wsdlsoap: binding style = "document" transport = "http://schemas.xmlsoap.org/soap/http"/> <wsdl: names: names "/wsdl: operação: slanded/slayt/http://schemas.xmlsoap.org/soap/http"/> <wsdl. Soapaction = "" /> <WSDL: Nome de entrada = "SayHelloreQuest"> <wsdlsoap: corpo use = "literal" /> < /wsdl: input> <wsdl: name de saída = "SayHellResponse"> <wsdlsoap: body use = "literal" /> < /wsdl ">