Apache CXF com POJO
Neste capítulo, você aprenderá a desenvolver um aplicativo da Web simples que envia uma mensagem de saudação ao usuário. Um projeto de serviço da web usa o modelo WSDL . O CXF permite ocultar esse modelo WSDL fornecendo um front-end simples para mapear APIs do Apache CXF para o WSDL subjacente.
Neste projeto mais simples, a interface do serviço da web será exposta diretamente ao cliente e o cliente usaria APIs CXF nativas do Apache para chamar o serviço da web.
Primeiro, criaremos um serviço da web. Todo serviço possui uma interface que é exposta ao cliente. Podemos escrever essa interface como uma interface simples do Apache CXF ou como um documento WSDL. Nesta abordagem do Apache CXF-First, exporemos nosso serviço por meio de uma interface do Apache CXF.
Desenvolvimento de serviço da web
O serviço que vamos criar na web terá um único método da web chamado greetings. O método leva umstringtipo de argumento no qual enviaremos o nome do usuário. O serviço enviará de volta uma mensagem de saudação ao chamador com o nome de usuário recebido incluído na mensagem.
Interface de serviço da web
Para expor a interface de nosso serviço da web, criaremos uma interface Apache CXF da seguinte maneira -
//HelloWorld.java
package com.tutorialspoint.cxf.pojo;
public interface HelloWorld {
String greetings(String text);
}A interface tem apenas um método chamado greetings. O servidor implementará esta interface. Em nossa aplicação trivial, essa interface é exposta diretamente ao cliente. Normalmente, em um aplicativo de serviço da web, você usa WSDL para descrever a interface do serviço da web. Neste aplicativo simples, forneceremos essa interface direta ao desenvolvedor do cliente. O cliente então ligaria para ogreetingsmensagem no objeto do servidor. Então, primeiro vamos criar o serviço da web.
Implementação de serviço web
o HelloWorld interface é implementada no HelloWorldImpl Classe Apache CXF conforme mostrado abaixo -
//HelloWorldImpl.java
package com.tutorialspoint.cxf.pojo;
public class HelloWorldImpl implements HelloWorld {
@Override
public String greetings(String text) {
return "Hi " + text;
}
}o greetings método recebe um parâmetro de string digite, anexa a uma mensagem de saudação e retorna a string resultante para o chamador.
Em seguida, escrevemos o aplicativo de servidor para hospedar o HelloWorld serviço.
Criando Servidor
O aplicativo de servidor consiste em duas partes -
A primeira parte cria uma fábrica para nosso serviço web, e
A segunda parte escreve um main método para instanciá-lo.
O servidor usa ServerFactoryBean classe fornecida por bibliotecas CXF para expor nosso HelloWorldinterface para clientes remotos. Assim, primeiro instanciamos oServerFactoryBean classe e, em seguida, defina suas várias propriedades -
ServerFactoryBean factory = new ServerFactoryBean();Definimos a classe de serviço a ser chamada chamando o setServiceClass método no factory objeto -
factory.setServiceClass(HelloWorld.class);Definimos a URL para chamar nosso serviço ligando para o setAddressmétodo. Observe que o serviço será publicado neste URL.
factory.setAddress("http://localhost:5000/Hello");Neste caso, o serviço é implantado no servidor embutido e estará escutando na porta 5000. Você pode optar por qualquer número de porta de sua escolha.
Antes de criar a fábrica, você precisa informá-la sobre nossa classe de implementação de serviço. Isso é feito chamando osetServiceBean método no factory objeto como mostrado aqui -
factory.setServiceBean(new HelloWorldImpl());O bean de serviço é definido como a instância de nossa classe de implementação de serviço. Finalmente, criamos a fábrica chamando seucreate método -
factory.create();Agora, como desenvolvemos a fábrica para executar nosso serviço da web, vamos escrever um main método para instanciá-lo e mantê-lo em execução por algum tempo.
Agora, escreva um main método para instanciar o HelloServer classe como segue -
public static void main(String[] args) throws Exception {
new HelloServer();
System.out.println("Listening on port 5000 ...");
}Uma vez instanciado, o HelloServera classe continuará funcionando indefinidamente. Para implantações de produção, você definitivamente manterá seu servidor funcionando para sempre. Na situação atual, encerraríamos o servidor após um tempo predeterminado da seguinte forma -
Thread.sleep(5 * 60 * 1000);
System.out.println("Server exiting ...");
System.exit(0);Todo o código para o HelloServer a aula é dada abaixo -
//HelloServer.java//HelloServer.java
package com.tutorialspoint.cxf.pojo;
import org.apache.cxf.frontend.ServerFactoryBean;
public class HelloServer {
protected HelloServer() throws Exception {
ServerFactoryBean factory = new ServerFactoryBean();
factory.setServiceClass(HelloWorld.class);
factory.setAddress("http://localhost:5000/Hello");
factory.setServiceBean(new HelloWorldImpl());
factory.create();
}
public static void main(String[] args) throws Exception {
new HelloServer();
System.out.println("Listening on port 5000 ...");
Thread.sleep(5 * 60 * 1000);
System.out.println("Server exiting ...");
System.exit(0);
}
}O aplicativo de servidor que criamos usa ServerFactoryBeanclasse das bibliotecas CXF. Devemos agora incluir essas bibliotecas em nosso projeto para compilar com sucesso oHelloServerclasse. Nós vamos usarMaven para configurar as dependências do projeto.
Configurando o Projeto Maven
Para criar um projeto Maven, digite o seguinte comando na janela da linha de comando. Observe que testamos isso em uma máquina Mac. Para instalações do Windows e Linux, as instruções podem ser diferentes em alguns lugares.
mvn archetype:generateQuando perguntado sobre as propriedades, insira os seguintes valores -
Define value for property 'groupId': : com.tutorialspoint
Define value for property 'artifactId': : cxf-pojo
Define value for property 'version': 1.0-SNAPSHOT: : 1.0
Define value for property 'package': com.tutorialspoint: : com.tutorialspoint.cxf.pojoAo concluir o comando maven, você encontrará a estrutura de pastas apropriada criada na pasta atual junto com o arquivo pom.xml.
A estrutura de diretório gerada é mostrada aqui -
Você adicionará as dependências CXF no pom.xmle também copie os arquivos Apache CXF criados acima para a pasta apropriada da estrutura criada pelo maven. Para sua referência, fornecemos abaixo o arquivo pom.xml para o projeto que criamos em nossa máquina.
<?xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoint</groupId>
<artifactId>cxf-pojo</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<profiles>
<profile>
<id>server</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.cxf.pojo.HelloServer
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
<profile>
<id>client</id>
<build>
<defaultGoal>test</defaultGoal>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>
com.tutorialspoint.cxf.pojo.HelloClient
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
<dependencies>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-features-logging</artifactId>
<version>3.3.0</version>
<type>jar</type>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-simple</artifactId>
<version>3.3.0</version>
<type>jar</type>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxws</artifactId>
<version>3.3.0</version>
</dependency>
<!-- Jetty is needed if you're using the CXFServlet -->
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http-jetty</artifactId>
<version>3.3.0</version>
</dependency>
</dependencies>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
</project>O pom.xml acima pode incluir dependências adicionais que são irrelevantes para este projeto, mas são necessárias para o nosso próximo projeto neste tutorial. De qualquer forma, não há mal nenhum em incluir dependências adicionais.
Estrutura da Pasta do Projeto
A estrutura de pastas do projeto em minha máquina após colocar os arquivos Apache CXF do servidor e do cliente é mostrada abaixo para sua referência rápida -
Servidor em execução
Para construir o projeto, use o seguinte comando em sua janela de linha de comando -
mvn clean installVocê pode iniciar o servidor usando o seguinte comando -
mvn -PserverIsso iniciará o servidor e você verá o seguinte prompt no console -
INFO: Creating Service {http://pojo.cxf.tutorialspoint.com/}HelloWorld from class com.tutorialspoint.cxf.pojo.HelloWorld
INFO: Setting the server's publish address to be http://localhost:5000/Hello
Listening on port 5000 ...Agora, na janela do seu navegador, especifique o URL do nosso serviço publicado. Você verá a seguinte saída -
Isso confirma que nosso serviço está sendo executado na porta especificada em um host local. Uma vez que não especificamos ogreetings mensagem em nossa chamada, uma mensagem de falha SOAP é retornada ao navegador.
Você pode testar ainda mais seu serviço da web usando um cliente SOAP de sua escolha. Aqui, usamos o Postman para testar nosso servidor.
A saída é como mostrado aqui -
Observe aquilo SOAP Requestfoi codificado manualmente. Depois de postar a solicitação, o servidor enviou umSOAP Response mensagem, que é vista na parte inferior da captura de tela.
A partir disso, você pode entender que o CXF mantém o uso de protocolos SOAP para solicitação e resposta, enquanto fornece uma visão unificada de uma variedade de tecnologias da web que existem no mundo atual. Isso simplifica muito o desenvolvimento de aplicativos da web.
Nossa próxima tarefa é criar um cliente que consumirá o serviço da web que você criou.
Criando Cliente
No aplicativo do servidor HelloWorldé a interface que expõe nosso serviço da web. O serviço da web em si apenas fornece uma mensagem de saudação simples ao cliente. Normalmente, a interface do serviço da web é exposta ao mundo externo usando WSDL (Web Services Description Language). Neste aplicativo trivial, iremos expor nosso serviço da web para o cliente, expondo diretamente a interface do serviço e que é oHelloWorld.class.
Para isso, o CXF fornece uma classe de fábrica chamada ClientProxyFactoryBean que nos permite anexar à interface desejada para a instância de fábrica criada.
Primeiro, criamos uma instância de bean de fábrica da seguinte maneira -
ClientProxyFactoryBean factory = new ClientProxyFactoryBean();Nós chamamos o setAddressna instância do bean de fábrica para definir a URL pela qual nosso serviço da web pode ser chamado. Em nosso caso, usaremos a URL usada ao criar o servidor em nossa etapa anterior -
factory.setAddress("http://localhost:5000/Hello");Em seguida, chamamos o create método no factory instância para anexar nossa interface de serviço HelloWorld.class para isso.
HelloWorld helloServer = factory.create(HelloWorld.class);Finalmente, chamamos o greetings método para chamar o serviço da web remoto.
System.out.println(helloServer.greetings(System.getProperty("user.name")));Isso imprimiria uma mensagem de saudação em seu console.
A fonte completa do aplicativo cliente é mostrada abaixo -
//HelloClient.java
package com.tutorialspoint.cxf.pojo;
import org.apache.cxf.frontend.ClientProxyFactoryBean;
public class HelloClient {
public static void main(String[] args) throws Exception {
ClientProxyFactoryBean factory = new ClientProxyFactoryBean();
factory.setAddress("http://localhost:5000/Hello");
HelloWorld helloServer = factory.create(HelloWorld.class);
System.out.println(helloServer.greetings(System.getProperty("user.name")));
}
}Cliente em execução
Certifique-se de que o servidor ainda esteja em execução em sua máquina. Caso tenha expirado, reinicie o servidor com o seguinte comando -
mvn -PserverVocê verá a seguinte mensagem no console -
Listening on port 5000 ...Agora, antes que o servidor expire o tempo definido para 5 minutos, abra outra janela de linha de comando e inicie o cliente com o seguinte comando -
mvn -PclientVocê verá uma mensagem semelhante à seguinte na linha de comando -
Hi tutorialspointObserve que tutorialspointé o nosso nome de usuário. Você receberá uma saudação com seu próprio nome.
No próximo capítulo, aprenderemos como usar o CXF em um projeto JAX-WS (Apache CXF API para XML Web Services).