Apache CXF com JAX-WS

Neste aplicativo JAX-WS, usaremos a abordagem Apache CXF primeiro, como o aplicativo POJO anterior. Portanto, primeiro criaremos uma interface para nosso serviço da web.

Declaração de interface de serviço

Como no caso anterior, criaremos um serviço trivial que possui apenas um método de interface chamado saudações. O código para a interface de serviço é mostrado abaixo -

//HelloWorld.java
package com.tutorialspoint.cxf.jaxws.helloworld;
import javax.jws.WebService;

@WebService
public interface HelloWorld {
   String greetings(String text);
}

Nós anotamos a interface com um @WebServicetag. A seguir, implementaremos essa interface.

Implementando Interface da Web

A implementação da interface da web é mostrada aqui -

//HelloWorldImpl.java
package com.tutorialspoint.cxf.jaxws.helloworld;
public class HelloWorldImpl implements HelloWorld {
   @Override
   public String greetings(String name) {
      return ("hi " + name);
   }
}

O método de saudação é anotado com @Overridetag. O método retorna uma mensagem "oi" ao chamador.

A seguir, escreveremos o código para desenvolver o servidor.

Servidor de Desenvolvimento

Ao contrário do aplicativo POJO, agora iremos desacoplar a interface usando a classe Endpoint fornecida pelo CXF para publicar nosso serviço. Isso é feito nas duas linhas de código a seguir -

HelloWorld implementor = new HelloWorldImpl();
Endpoint.publish(
   "http://localhost:9090/HelloServerPort",
   implementor,
   new LoggingFeature()
);

O primeiro parâmetro do método de publicação especifica a URL na qual nosso serviço será disponibilizado aos clientes. O segundo parâmetro especifica a classe de implementação para nosso serviço. Todo o código do servidor é mostrado abaixo -

//Server.java
package com.tutorialspoint.cxf.jaxws.helloworld;
import javax.xml.ws.Endpoint;
import org.apache.cxf.ext.logging.LoggingFeature;
public class Server {
   public static void main(String[] args) throws Exception {
      HelloWorld implementor = new HelloWorldImpl();
      Endpoint.publish("http://localhost:9090/HelloServerPort",
      implementor,
      new LoggingFeature());
      System.out.println("Server ready...");
      Thread.sleep(5 * 60 * 1000);
      System.out.println("Server exiting ...");
      System.exit(0);
   }
}

Para implantar nosso servidor, você precisará fazer mais algumas modificações em seu projeto, conforme listado abaixo.

Servidor de implantação

Finalmente, para implantar o aplicativo do servidor, você precisará fazer mais uma modificação em pom.xml para configurar seu aplicativo como um aplicativo da web. O código que você precisa adicionar ao seupom.xml é dado abaixo -

<profiles>
   <profile>
      <id>server</id>
      <build>
         <defaultGoal>test</defaultGoal>
         <plugins>
            <plugin>
               <groupId>org.codehaus.mojo</groupId>
               <artifactId>exec-maven-plugin</artifactId>
               <version>1.6.0</version>
               <executions>
                  <execution>
                     <phase>test</phase>
                     <goals>
                        <goal>java</goal>
                     </goals>
                     <configuration>
                        <mainClass>
                           com.tutorialspoint.cxf.jaxws.helloworld.Server
                        </mainClass>
                     </configuration>
                  </execution>
               </executions>
            </plugin>
         </plugins>
      </build>
   </profile>
</profiles>

Antes de implantar o aplicativo, você precisa adicionar mais dois arquivos ao seu projeto. Eles são mostrados na imagem abaixo -

Esses arquivos são arquivos padrão CXF que definem o mapeamento para CXFServlet. O código dentro doweb.xml arquivo é mostrado aqui para sua referência rápida -

//Web.xml
<?xml version = "1.0" encoding = "UTF-8"??>
<web-app xmlns = "http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.5"
xsi:schemaLocation = "http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
   <display-name>cxf</display-name>
   <servlet>
      <description>Apache CXF Endpoint</description>
      <display-name>cxf</display-name>
      <servlet-name>cxf</servlet-name>
      <servlet-class>
         org.apache.cxf.transport.servlet.CXFServlet
      </servlet-class>
      <load-on-startup>
         1
      </load-on-startup>
   </servlet>
   <servlet-mapping>
      <servlet-name>
         cxf
      </servlet-name>
      <url-pattern>
         /services/*
      </url-pattern>
   </servlet-mapping>
   <session-config>
      <session-timeout>60</session-timeout>
   </session-config>
</web-app>

No cxf-servlet.xml,você declara as propriedades do ponto de extremidade do seu serviço. Isso é mostrado no snippet de código abaixo -

<beans ...>
   <jaxws:endpoint xmlns:helloworld = "http://tutorialspoint.com/"
      id = "helloHTTP"
      address = "http://localhost:9090/HelloServerPort"
      serviceName = "helloworld:HelloServiceService"
      endpointName = "helloworld:HelloServicePort">
   </jaxws:endpoint>
</beans>

Aqui definimos a id para nosso endpoint de serviço, o endereço no qual o serviço estará disponível, o nome do serviço e o nome do endpoint. Agora, você aprendeu como seu serviço é roteado e processado por um servlet CXF.

O pom.xml final

o pom.xmlinclui mais algumas dependências. Em vez de descrever todas as dependências, incluímos a versão final de pom.xml abaixo -

<?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-jaxws</artifactId>
   <version>1.0</version>
   <packaging>jar</packaging>
   <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>
   <profiles>
      <profile>
         <id>server</id>
         <build>
            <defaultGoal>test</defaultGoal>
            <plugins>
               <plugin>
                  <groupId>org.codehaus.mojo</groupId>
                  <artifactId>exec-maven-plugin</artifactId>
                  <version>1.6.0</version>
                  <executions>
                     <execution>
                        <phase>test</phase>
                        <goals>
                           <goal>java</goal>
                        </goals>
                        <configuration>
                           <mainClass>
                              com.tutorialspoint.cxf.jaxws.helloworld.Server
                           </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.jaxws.helloworld.Client
                           </mainClass>
                        </configuration>
                     </execution>
                  </executions>
               </plugin>
            </plugins>
         </build>
      </profile>
   </profiles>
   <dependencies>
      <dependency>
         <groupId>org.apache.cxf</groupId>
         <artifactId>cxf-rt-frontend-jaxws</artifactId>
         <version>3.3.0</version>
      </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-features-logging</artifactId>
         <version>3.3.0</version>
      </dependency>
      <dependency>
         <groupId>org.apache.cxf</groupId>
         <artifactId>cxf-rt-transports-http-jetty</artifactId>
         <version>3.3.0</version>
      </dependency>
   </dependencies>
</project>

Observe que também inclui um perfil para construir o cliente que aprenderemos nas seções posteriores deste tutorial.

Executando o serviço HelloWorld

Agora você está pronto para executar o aplicativo da web. Na janela de comando, execute o script de construção usando o seguinte comando.

mvn clean install

mvn -Pserver

Você verá a seguinte mensagem no console -

INFO: Setting the server's publish address to be http://localhost:9090/HelloServerPort
Server ready…

Como anteriormente, você pode testar o servidor abrindo a URL do servidor em seu navegador.

Como não especificamos nenhuma operação, apenas uma mensagem de falha é retornada ao navegador por nosso aplicativo.

Agora, tente adicionar o ?wsdl ao seu URL e você verá a seguinte saída -

Portanto, nosso aplicativo de servidor está funcionando conforme o esperado. Você pode usar o cliente SOAP, comoPostman descrito anteriormente para testar ainda mais seu serviço.

Na próxima seção, aprenderemos como escrever um cliente que usa nosso serviço.

Cliente em desenvolvimento

Escrever o cliente em um aplicativo CXF é tão trivial quanto escrever um servidor. Aqui está o código completo para o cliente -

//Client.java
package com.tutorialspoint.cxf.jaxws.helloworld;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;
import javax.xml.ws.soap.SOAPBinding;
public final class Client {
   private static final QName SERVICE_NAME
   = new QName("http://helloworld.jaxws.cxf.tutorialspoint.com/",
   "HelloWorld");
   private static final QName PORT_NAME
   = new QName("http://helloworld.jaxws.cxf.tutorialspoint.com/",
   "HelloWorldPort");
   private Client() {
   }
   public static void main(String[] args) throws Exception {
      Service service = Service.create(SERVICE_NAME);
      System.out.println("service created");
      String endpointAddress = "http://localhost:9090/HelloServerPort";
      service.addPort(PORT_NAME, SOAPBinding.SOAP11HTTP_BINDING,
      endpointAddress);
      HelloWorld hw = service.getPort(HelloWorld.class);
      System.out.println(hw.greetings("World"));
   }
}

Aqui, usamos o CXF fornecido Serviceclasse para vincular ao serviço conhecido. Nós chamamos ocreate método no Serviceclasse para obter uma instância do serviço. Definimos a porta conhecida chamando oaddPort método no service instância.

Agora, estamos prontos para consumir o serviço, o que fazemos obtendo primeiro a interface do serviço chamando o getPort método no serviceinstância. Finalmente, chamamos nossogreetings método para imprimir a mensagem de saudação no console.

Agora, como você aprendeu os fundamentos do CXF usando a abordagem Apache CXF-First, você aprenderá como usar o CXF com a abordagem WSDL-First em nosso próximo capítulo.