Exemplos de Serviço da Web da Plataforma Team

Voltar à página anterior.

Visão Geral

Esses exemplos incluem três interfaces de serviço, suas implementações, um factory de interface de serviço, um programa cliente para realizar os serviços, e um plugin.xml que pode registrar os serviços.

Para executar isso no servidor, será necessário ter a versão compilada dos arquivos Java (exceto ExampleClient), e o plugin.xml disponível do caminho de classe do servlet team atualmente em execução. ExampleClient executa como um cliente.

IExampleService.java

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

/**
 * Serviço RPC de exemplo que pode executar operações matemáticas integrais simples.
 */
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

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

/**
 * Implementação de IExampleService.
 */
classe pública ExampleService implements IExampleService {

	// implemente os métodos do modo típico
	
	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

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

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

/**
 * Serviço de conteúdo de exemplo.
 * Note que normalmente você não incluirá nenhum método nessa interface,
 * porém, você pode desejar colocar algumas constantes compartilhadas aqui.
 */
interface pública IExampleContentService estende ITeamContentService {
}

ExampleContentService.java

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

importar java.io.ByteArrayInputStream;
importar java.io.IOException;

importar java.sql.Timestamp;

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

/**
 * Implementação de IExampleContentServer.
 */
a classe pública ExampleContentService implementa IExampleContentService {
	
	// contar o número de vezes que esse serviço foi chamado.
	contador int privado estático = 0;
	
	/**
	 * Esse método retorna o conteúdo especificado pela URI.  
	 * Isso é usado para transformar dados do servidor para o cliente.
	 */
	public TeamContent get(URI da cadeia) lança IOException {
		
		// obter uma instância do IExampleService
		IExampleService exampleService = (IExampleService) ITeamServiceContext.Current.getPeerService(IExampleService.class);
		
		// usar esse serviço para atualizar o contador
		contador = exampleService.add(contador, 1);
		
		// construir algum HTML para enviar de volta
		Página da cadeia = "<p>Você solicitou URI: <código>'" + URI + "'</código>.\n";
		página += "<p>Você chamou esse serviço " + contador + " horário" + (contador == 1 ? "" : "s") + ".\n";
		
		byte[] pageBytes = page.getBytes("UTF-8");
		
		// compilar nosso objeto TeamContent a ser retornado
		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;
	}

	/**
	 * Esse método armazena o conteúdo especificado.  
	 * Isso é usado para transferir dados do cliente para o servidor.
	 */
	public void put(TeamContent teamContent) lança IOException {
		// não faz nada, assim não há como enviar dados do
		// cliente para o servidor com essa interface
	}

}

IExampleRestService.java

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

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

/**
 * Serviço REST de exemplo.
 * Note que normalmente você não incluirá nenhum método nessa interface,
 * porém, você pode desejar colocar algumas constantes compartilhadas aqui.
 */
public interface IExampleRestService estende ITeamRestService {
}

ExampleRestService.java

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

importar java.util.Date;

importar java.io.IOException;
importar java.io.Writer;

importar javax.servlet.http.HttpServletRequest;
importar javax.servlet.http.HttpServletResponse;

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

/**
 * Implementação de IExampleRestService.
 * Note que essa classe estende TeamRestService, que fornece uma maneira de manipular
 * métodos específicos sem verificar o método de HTTP no método de serviço.
 */
public class ExampleRestService estende TeamRestService implementa IExampleRestService {

	// contar o número de vezes que esse serviço foi chamado.
	contador int privado estático = 0;
	
	/**
	 * Implementação do método GET.
	 */
	public void perform_GET(String uri, ITeamServiceContext teamServiceContext) lança IOException {
		
		// obter uma instância do IExampleService
		IExampleService exampleService = (IExampleService) teamServiceContext.getPeerService(IExampleService.class);
		
		// usar esse serviço para atualizar o contador
		contador = exampleService.add(contador, 1);
		
		// obter a solicitação de HTTP e responder a partir do contexto
		HttpServletRequest  request  = teamServiceContext.getHttpServletRequest();
		HttpServletResponse response = teamServiceContext.getHttpServletResponse();
		
		// obter um Writer no fluxo de saída
		Writer writer = response.getWriter();
		
		// gravar algum HTML
		response.setContentType("text/html");
		writer.write("<p>Você pediu: '" + uri + "'.\n");
		writer.write("<p>A cadeia de consultas era: '" + request.getQueryString() + ".\n");
		writer.write("<p>Você chamou esse serviço " + counter + " time" + (counter == 1 ? "" : "s") + ".\n");
		writer.write("<p>O horário atual é " + new Date() + ".\n");
	}

}

ExampleClient.java

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

importar java.io.IOException;
importar java.io.InputStream;

importar org.apache.commons.httpclient.HttpMethod;

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

/**
 * O método principal dessa classe chama alguns serviços como um cliente.
 */
public class ExampleClient {

	/**
	 * Copiar um fluxo de entrada para System.out 
	 */
	static private void copyToSystemOut(InputStream iStream) lança 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------------------");
	}
	
	/**
	 * Método que faz todas as chamadas de serviço. 
	 */
	static public void main(String[] args) lança IOException {
		
		// criar uma nova configuração remota, configurando a URL
		RemoteTeamServerConfiguration config = new RemoteTeamServerConfiguration();
		config.setURL("http://localhost:9080/jazz");

		// criar o servidor remoto team, incluir alguns serviços
		RemoteTeamServer server = RemoteTeamServer.create(config);
		server.addService(IExampleService.class, null);
		server.addService(IExampleContentService.class, null);
		server.addService(IExampleRestService.class, null);
		
		// obter os objetos de implementação de serviço
		IExampleService        rpcService     = (IExampleService)        server.getServiceImplementation(IExampleService.class);
		IExampleContentService contentService = (IExampleContentService) server.getServiceImplementation(IExampleContentService.class);
		
		// note que a implementação nesse caso NÃO implementa a interface;
		// Serviços REST diferem dessa maneira
		ITeamRestServiceClient restService    = (ITeamRestServiceClient) server.getServiceImplementation(IExampleRestService.class);
		
		// chamar um serviço RPC
		int result = rpcService.add(1, 2);
		System.out.println("\nTurns out, 1 + 2 = " + result + ", after all.");
		
		// chamar um serviço de conteúdo
		TeamContent teamContent = contentService.get("/something");
		InputStream iStream     = teamContent.getInputStream();
		System.out.println("\nContent from content service :: /something:");
		try {
			copyToSystemOut(iStream);
		}
		// certificar-se de que o fluxo de entrada de TeamContent está fechado, ou o
		// soquete subjacente não será fechado
		finally {
			if (null != iStream) iStream.close();
		}
		
		// chamar um serviço REST
		HttpMethod method = restService.getGetMethod("/something-else");
		
		try {
			restService.executeMethod(method);
			
			System.out.println("\nContent from REST service :: /something-else:");
			copyToSystemOut(method.getResponseBodyAsStream());
		}
		// certificar-se de que o método chama releaseConneciton(), ou o
		// soquete subjacente não será fechado
		finally {
			method.releaseConnection();
		}
		
	}
	
}

TeamServiceInterfaceFactory.java

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

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

/**
 * Uma classe factory usada durante o registro de serviços por meio do eclipse
 * plug-ins para carregar instâncias de suas classes de serviço.
 * Nada especial aqui, apenas precisamos poder carregar uma instância
 * de Classe com um determinado nome, da maneira óbvia. Não é necessário
 * fazer nada mais elaborado, porém, você precisará de uma delas em
 * cada um de seus jars de plug-in do servidor.
 */
public class TeamServiceInterfaceFactory implementa 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" 
	versão       = "1.0.0"
	nome do provedor = "IBM">
	
	<ponto de extensão="com.ibm.team.core.services.serviceProvider">
		
		<serviço 
			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                  = "Serviço RPC de Exemplo"
		/>
		
		<serviço 
			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                  = "Example Content Service"
		/>
		
		<serviço 
			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                  = "Serviço REST de Exemplo"
		/>
		
	</extensão>
	
</plug-in>
Voltar à página anterior.