Apache CXF con JAX-RS
Prima di procedere in questo capitolo, presumiamo che tu sappia come scrivere un servizio web RESTful in Java. Ti mostrerò come utilizzare CXF in cima a questo JAX-RS (API Java per servizi Web RESTful). Creeremo un servizio web che mantiene un elenco degli ultimi film. Quando l'utente richiede un film, specifica l'ID del film nella sua richiesta, il server individuerà il film e lo restituirà al client. Nel nostro caso banale, restituiremo semplicemente il nome del film al client e non l'effettivo file binario MP4. Quindi iniziamo a creare un'applicazione JAX-RS.
Dichiarazione dell'elemento filmato
Dichiareremo un elemento radice XML chiamato Movie per memorizzare l'id e il nome di un dato film. L'elemento è dichiarato in un file chiamato Movie.java. Il contenuto del file è mostrato qui -
//Movie.java
package com.tutorialspoint.cxf.jaxrs.movie;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "Movie")
public class Movie {
private long id;
private String name;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Notare l'uso di XmlRootElement tag per dichiarare l'elemento XML per il Movieetichetta. Successivamente, creeremo un servizio che contiene l'elenco dei film nel suo database.
Creazione del database del servizio di film
Per memorizzare l'elenco dei film utilizziamo Java fornito Mapche memorizza le coppie chiave-valore. Se l'elenco è grande, utilizzerai un archivio di database esterno che sarà anche più facile da gestire. Nel nostro caso banale, memorizzeremo solo cinque film nel nostro database. Il codice per la classe MovieService è fornito di seguito:
//MovieService.java
package com.tutorialspoint.cxf.jaxrs.movie;
import java.util.HashMap;
import java.util.Map;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
@Path("/movieservice/")
@Produces("text/xml")
public class MovieService {
long currentId = 123;
Map<Long, Movie> movies = new HashMap<>();
public MovieService() {
init();
}
@GET
@Path("/movie/{id}/")
public Movie getMovie(@PathParam("id") String id) {
long idNumber = Long.parseLong(id);
return movies.get(idNumber);
}
final void init() {
Movie c1 = new Movie();
c1.setName("Aquaman");
c1.setId(1001);
movies.put(c1.getId(), c1);
Movie c2 = new Movie();
c2.setName("Mission Imposssible");
c2.setId(1002);
movies.put(c2.getId(), c2);
Movie c3 = new Movie();
c3.setName("Black Panther");
c3.setId(1003);
movies.put(c3.getId(), c3);
Movie c4 = new Movie();
c4.setName("A Star is Born");
c4.setId(1004);
movies.put(c4.getId(), c4);
Movie c5 = new Movie();
c5.setName("The Meg");
c5.setId(1005);
movies.put(c5.getId(), c5);
}
}
Nota che usiamo le seguenti due annotazioni per specificare il percorso dell'URL per il nostro servizio di film e il suo tipo di ritorno -
@Path("/movieservice/")
@Produces("text/xml")
Usiamo le annotazioni @GET e @Path per specificare l'URL per la richiesta GET come segue:
@GET
@Path("/movie/{id}/")
Il database del film stesso viene inizializzato nel metodo init, dove aggiungiamo cinque elementi del film al database.
Il nostro prossimo compito è scrivere un'applicazione server.
Server di sviluppo
Per creare un server, utilizziamo CXF fornito JAXRSServerFactoryBean classe.
JAXRSServerFactoryBean factory = new JAXRSServerFactoryBean();
Impostiamo le sue classi di risorse chiamando il setResourceClasses metodo.
factory.setResourceClasses(Movie.class);
factory.setResourceClasses(MovieService.class);
Impostiamo il fornitore di servizi chiamando il setResourceProvider metodo.
factory.setResourceProvider(MovieService.class,
new SingletonResourceProvider(new MovieService()));
Impostiamo il desiderato publish indirizzo chiamando il aetAddress metodo -
factory.setAddress("http://localhost:9000/");
Infine, pubblichiamo il server chiamando il metodo create sul file factory esempio.
factory.create();
Di seguito è riportato l'intero codice per l'applicazione server:
//Server.java
package com.tutorialspoint.cxf.jaxrs.movie;
import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;
import org.apache.cxf.jaxrs.lifecycle.SingletonResourceProvider;
public class Server {
public static void main(String[] args) throws Exception {
JAXRSServerFactoryBean factory = new JAXRSServerFactoryBean();
factory.setResourceClasses(Movie.class);
factory.setResourceClasses(MovieService.class);
factory.setResourceProvider(MovieService.class,
new SingletonResourceProvider(new MovieService()));
factory.setAddress("http://localhost:9000/");
factory.create();
System.out.println("Server ready...");
Thread.sleep(5 * 60 * 1000);
System.out.println("Server exiting ...");
System.exit(0);
}
}
The Final pom.xml
Qui abbiamo incluso la versione finale di pom.xml di seguito -
<?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-jaxrs</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.jaxrs.movie.Server
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http-jetty</artifactId>
<version>3.3.0</version>
</dependency>
</dependencies>
</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.jaxrs.movie.Client
</mainClass>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
<dependencies>
<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-transports-http-jetty</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxrs</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>jakarta.ws.rs</groupId>
<artifactId>jakarta.ws.rs-api</artifactId>
<version>2.1.5</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.7</version>
</dependency>
</dependencies>
</project>
Cliente in via di sviluppo
Scrivere il client RS è banale. Creiamo semplicemente un oggetto URL e apriamo il suo flusso. Usiamo la classe IOUtils fornita da CXF per copiare il contenuto del flusso di input in un flusso locale.
URL url = new URL("http://localhost:9000/movieservice/movie/1002");
try (InputStream instream = url.openStream();
CachedOutputStream outstream = new CachedOutputStream()) {
IOUtils.copy(instream, outstream);
}
Di seguito viene fornito l'intero codice per l'applicazione client:
//Client.java
package com.tutorialspoint.cxf.jaxrs.movie;
import java.io.InputStream;
import java.net.URL;
import org.apache.cxf.helpers.IOUtils;
import org.apache.cxf.io.CachedOutputStream;
public class Client {
public static void main(String[] args) throws Exception {
URL url = new URL("http://localhost:9000/movieservice/movie/1002");
try (InputStream instream = url.openStream();
CachedOutputStream outstream = new CachedOutputStream()) {
IOUtils.copy(instream, outstream);
String str = outstream.getOut().toString();
System.out.println(str);
}
}
}
Test dell'applicazione JAX-RS
Eseguire il server utilizzando il seguente comando nella finestra della riga di comando:
mvn -Pserver
Ora vedrai il seguente messaggio sulla console:
INFO: Setting the server's publish address to be http://localhost:9000
Ora apri il browser e digita il seguente URL:
http://localhost:9000/movieservice/movie/1002
Vedrai quanto segue nella finestra del browser.
![](https://assets.edu.lat/apache_cxf/images/browser_window.jpg)
È possibile richiamare il servizio utilizzando un'applicazione client Java che abbiamo sviluppato eseguendo il seguente comando in una finestra della riga di comando separata.
mvn -Pclient
Vedrai il seguente output:
<?xml version="1.0" encoding = "UTF-8" standalone="yes"?>
<Movie><id>1002</id><name>Mission Imposssible</name></Movie>
Gli esempi CXF forniscono diversi esempi su come utilizzare CXF con JAX-RS. I lettori interessati sono incoraggiati a studiare questi campioni.