Esempi di servizi Web della piattaforma team

Torna alla pagina precedente.

Panoramica

Questi esempi includono tre interfacce di servizi, le loro implementazioni, una factory della interfaccia del servizio, un programma del client per le esercitazioni con i servizi e un plugin.xml che può registrare i servizi.

Per eseguire queste operazioni sul server, sarà necessario avere la versione compilata dei file java (ad eccezione di ExampleClient) e plugin.xml disponibile dal percorso classi del servlet team in esecuzione. ExampleClient viene eseguito come client.

IExampleService.java

package com.ibm.team.core.services.examples;

/**
 * Servizio RPC di esempio che può eseguire delle semplici operazioni di matematica integrali.
 */
public interface IExampleService {

	public int add(int x, int y);
	public int sub(int x, int y);
	public int mul(int x, int y);
	public int div(int x, int y);
}

ExampleService.java

package com.ibm.team.core.services.examples;

/**
 * Implementazione di IExampleService.
 */
public class ExampleService implements IExampleService {

	// implementare i metodi nella modalità tipica
	
	public int add(int x, int y) { return x + y; }
	public int sub(int x, int y) { return x - y; }
	public int mul(int x, int y) { return x * y; }
	public int div(int x, int y) { return x / y; }

}

IExampleContentService.java

package com.ibm.team.core.services.examples;

import com.ibm.team.core.services.ITeamContentService;

/**
 * Esempio di servizio del contenuto.
 * Da notare che normalmente non si aggiungono metodi a questa interfaccia,
 * tuttavia è consigliabile immettere qui delle costanti condivise.
 */
public interface IExampleContentService extends ITeamContentService {
}

ExampleContentService.java

package com.ibm.team.core.services.examples;

import java.io.ByteArrayInputStream;
import java.io.IOException;

import java.sql.Timestamp;

import com.ibm.team.core.services.ITeamServiceContext;
import com.ibm.team.core.services.TeamContent;

/**
 * Implementazione di IExampleContentServer.
 */
public class ExampleContentService implements IExampleContentService {
	
	// contare le volte che questo servizio è stato chiamato.
	static private int counter = 0;
	
	/**
	 * Questo metodo restituisce il contenuto specificato dall'URI.  
	 * Viene utilizzato per trasferire i dati dal server al client.
	 */
	public TeamContent get(String uri) throws IOException {
		
		// ottenere un'istanza di IExampleService
		IExampleService exampleService = (IExampleService) ITeamServiceContext.Current.getPeerService(IExampleService.class);
		
		// utilizzare tale servizio per aggiornare il contatore
		counter = exampleService.add(counter, 1);
		
		// creare HTML da restituire
		String page = "<p>È stato richiesto l'URI: <code>'" + uri + "'</code>.\n";
		page += "<p>Questo servizio è stato chiamato " + counter + " time" + (counter == 1 ? "" : "s") + ".\n";
		
		byte[] pageBytes = page.getBytes("UTF-8");
		
		// creare l'oggetto TeamContent da restituire
		TeamContent teamContent = new TeamContent();
		teamContent.setContentType("text/html;; charset=utf-8");
		teamContent.setLastModified(new Timestamp(System.currentTimeMillis()));
		teamContent.setInputStream(new ByteArrayInputStream(pageBytes));
		teamContent.setSize(pageBytes.length);
		
		return teamContent;
	}

	/**
	 * Questo metodo archivia il contenuto specificato.  
	 * Viene utilizzato per trasferire i dati dal client al server.
	 */
	public void put(TeamContent teamContent) throws IOException {
		// non esegue nulla, pertanto non vi è modo di inviare dati dal
		// client al server con questa interfaccia
	}

}

IExampleRestService.java

package com.ibm.team.core.services.examples;

import com.ibm.team.core.services.ITeamRestService;

/**
 * Esempio di servizio REST.
 * Da notare che normalmente non si aggiungono metodi a questa interfaccia,
 * tuttavia è consigliabile immettere qui delle costanti condivise.
 */
public interface IExampleRestService extends ITeamRestService {
}

ExampleRestService.java

package com.ibm.team.core.services.examples;

import java.util.Date;

import java.io.IOException;
import java.io.Writer;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.ibm.team.core.services.ITeamServiceContext;
import com.ibm.team.core.services.TeamRestService;

/**
 * Implementazione di IExampleRestService.
 * Da notare che questa classe estende TeamRestService che fornisce una modalità di gestione
 * di metodi specifici senza controllare il metodo HTTP nel metodo del servizio.
 */
public class ExampleRestService extends TeamRestService implements IExampleRestService {

	// contare le volte che questo servizio è stato chiamato.
	static private int counter = 0;
	
	/**
	 * Implementazione del metodo GET.
	 */
	public void perform_GET(String uri, ITeamServiceContext teamServiceContext) throws IOException {
		
		// ottenere un'istanza di IExampleService
		IExampleService exampleService = (IExampleService) teamServiceContext.getPeerService(IExampleService.class);
		
		// utilizzare tale servizio per aggiornare il contatore
		counter = exampleService.add(counter, 1);
		
		// ottenere la richiesta e la risposta HTTP dal contesto
		HttpServletRequest  request  = teamServiceContext.getHttpServletRequest();
		HttpServletResponse response = teamServiceContext.getHttpServletResponse();
		
		// ottenere un programma di utilità di scrittura sullo stream di output
		Writer writer = response.getWriter();
		
		// scrivere del codice HTML
		response.setContentType("text/html");
		writer.write("<p>È stato richiesto: '" + uri + "'.\n");
		writer.write("<p>La stringa della query era: '" + request.getQueryString() + ".\n");
		writer.write("<p>Questo servizio è stato chiamato " + counter + " time" + (counter == 1 ? "" : "s") + ".\n");
		writer.write("<p>L'ora corrente è " + new Date() + ".\n");
	}

}

ExampleClient.java

package com.ibm.team.core.services.examples;

import java.io.IOException;
import java.io.InputStream;

import org.apache.commons.httpclient.HttpMethod;

import com.ibm.team.core.services.ITeamRestServiceClient;
import com.ibm.team.core.services.RemoteTeamServer;
import com.ibm.team.core.services.RemoteTeamServerConfiguration;
import com.ibm.team.core.services.TeamContent;

/**
 * Il metodo principale di questa classe chiama alcuni servizi come client.
 */
public class ExampleClient {

	/**
	 * Copiare uno stream di input in System.out 
	 */
	static private void copyToSystemOut(InputStream iStream) throws IOException {
		System.out.println("------------------");
		
		byte[] buffer = new byte[8192];
		int    read;
		while ((read=iStream.read(buffer)) > 0) { 
			System.out.write(buffer,0,read);
		}
		
		System.out.println("\n------------------");
	}
	
	/**
	 * Il metodo che esegue tutte le chiamate di servizio. 
	 */
	static public void main(String[] args) throws IOException {
		
		// creare una nuova configurazione remota, impostando l'URL
		RemoteTeamServerConfiguration config = new RemoteTeamServerConfiguration();
		config.setURL("http://localhost:9080/jazz");

		// creare il server team remoto, aggiungere alcuni servizi
		RemoteTeamServer server = RemoteTeamServer.create(config);
		server.addService(IExampleService.class, null);
		server.addService(IExampleContentService.class, null);
		server.addService(IExampleRestService.class, null);
		
		// ottenere gli oggetti di implementazione del servizio
		IExampleService        rpcService     = (IExampleService)        server.getServiceImplementation(IExampleService.class);
		IExampleContentService contentService = (IExampleContentService) server.getServiceImplementation(IExampleContentService.class);
		
		// Da notare che l'implementazione in questo caso NON implementa la interfaccia;
		// I servizi REST differiscono nel seguente modo
		ITeamRestServiceClient restService    = (ITeamRestServiceClient) server.getServiceImplementation(IExampleRestService.class);
		
		// chiamare un servizio RPC
		int result = rpcService.add(1, 2);
		System.out.println("\nTurns out, 1 + 2 = " + result + ", after all.");
		
		// chiamare un servizio del contenuto
		TeamContent teamContent = contentService.get("/something");
		InputStream iStream     = teamContent.getInputStream();
		System.out.println("\nContenuto dal servizio del contenuto :: /something:");
		try {
			copyToSystemOut(iStream);
		}
		// assicurarsi che lo stream di input TeamContent sia chiuso, altrimenti
		// il socket sottostante non verrà chiuso
		finally {
			if (null != iStream) iStream.close();
		}
		
		// chiamare un servizio REST
		HttpMethod method = restService.getGetMethod("/something-else");
		
		try {
			restService.executeMethod(method);
			
			System.out.println("\nContenuto dal servizio REST :: /something-else:");
			copyToSystemOut(method.getResponseBodyAsStream());
		}
		// accertarsi che il metodo chiami releaseConneciton(), altrimenti
		// il socket sottostante non verrà chiuso
		finally {
			method.releaseConnection();
		}
		
	}
	
}

TeamServiceInterfaceFactory.java

package com.ibm.team.core.services.examples;

import com.ibm.team.core.services.registry.ITeamServiceInterfaceFactory;

/**
 * Una classe factory utilizzata durante la registrazione dei servizi mediante i plug-in
 * di eclipse per caricare le istanze delle classi di servizio.
 * Niente di particolare qui, occorre semplicemente poter caricare un'istanza
 * di Class con un dato nome, nella maniera ovvia. Non occorre
 * eseguire nulla di più elaborato, tuttavia occorrerà una di queste classi
 * in ognuno dei jar dei plug-in del server.
 */
public class TeamServiceInterfaceFactory implements ITeamServiceInterfaceFactory {

	public Class getServiceInterface(String interfaceClassName) {
		try {
			return Class.forName(interfaceClassName);
		} 
		
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
		return null;
	}

}

plugin.xml

<?xml version="1.0" encoding="utf-8"?>
<?eclipse version="3.0"?>

<plugin 
	id            = "com.ibm.team.core.services.examples"
	nome          = "com.ibm.team.core.services.examples" 
	versione      = "1.0.0"
	nome provider = "IBM">
	
	<extension point="com.ibm.team.core.services.serviceProvider">
		
		<service 
			id                    = "com.ibm.team.core.services.examples.IExampleService"
			interfaceClass        = "com.ibm.team.core.services.examples.IExampleService"
			implementationClass   = "com.ibm.team.core.services.examples.ExampleService"
			interfaceFactoryClass = "com.ibm.team.core.services.examples.TeamServiceInterfaceFactory"
			nome                  = "Servizio RPC di esempio"
		/>
		
		<service 
			id                    = "com.ibm.team.core.services.examples.IExampleContentService"
			interfaceClass        = "com.ibm.team.core.services.examples.IExampleContentService"
			implementationClass   = "com.ibm.team.core.services.examples.ExampleContentService"
			interfaceFactoryClass = "com.ibm.team.core.services.examples.TeamServiceInterfaceFactory"
			nome                  = "Servizio del contenuto di esempio"
		/>
		
		<service 
			id                    = "com.ibm.team.core.services.examples.IExampleRestService"
			interfaceClass        = "com.ibm.team.core.services.examples.IExampleRestService"
			implementationClass   = "com.ibm.team.core.services.examples.ExampleRestService"
			interfaceFactoryClass = "com.ibm.team.core.services.examples.TeamServiceInterfaceFactory"
			nome                  = "Servizio REST di esempio"
		/>
		
	</extension>
	
</plugin>
Torna alla pagina precedente.