Veremos neste artigo como consumir um serviço REST utilizando a própria API Java com o auxílio do JAXB, especificação adicionada a partir da JDK 6. Para facilitar o entendimento, iremos construir uma aplicação responsável por disponibilizar um Web Service Rest e consumir este serviço. Este artigo se limitará a explicar o consumo do serviço.

Inicialmente, iremos disponibilizar o Web Service REST utilizando o framework RESTEasy, enquanto que o cliente, ou seja, a aplicação que irá consumir o serviço, será implementada utilizando a própria linguagem Java. A listagem 1 mostra o XML que será disponibilizado pelo Web Service Rest

Listagem 1: Exemplo de XML exposto como serviço

<?xml version="1.0" encoding="UTF-8"?>
<banda>
	<nome>Led Zeppelin<nome>
	<album>
		<nome>Led Zeppelin</nome>
		<ano>1969</ano>
		<musicas>
			<musica>
				<nome>Good Times Bad Times</nome>
			</musica>
			<musica>
				<nome>You Shook Me</nome>
			</musica>
		</musicas>
	</album>
</banda>

O Web Service Rest, conforme pode ser visto pelo XML, expõe algumas informações sobre uma determinada banda de música. No exemplo, a nossa banda é o Led Zeppelin (yeah, essa eu curto). A banda deve ter um nome e um álbum. O álbum por sua vez, tem um nome, o ano de lançamento, e como todo bom álbum, tem músicas . Pelo fato do XML ser uma linguagem estruturada, podemos ter uma idéia de como serão nossas classes Java. A Listagem 2 mostra a classe Banda, a Listagem 3 mostra a classe Album, e a Listagem 4 mostra a classe Musica, todas já com as anotações JAXB correspondentes.

Listagem 2: Classe Banda

@XmlRootElement(name="banda")
public class Banda {
	
	private String nome;
	private Album album;
	
	@XmlElement
	public String getNome() {
		return nome;
	}
	public void setNome(String nome) {
		this.nome = nome;
	}
	@XmlElement
	public Album getAlbum() {
		return album;
	}
	public void setAlbum(Album album) {
		this.album = album;
	}
}

Listagem 3: Classe Album

public class Album {

	private String nome;
	private int ano;
	private List<Musica> musicas;
	
	@XmlElement
	public String getNome() {
		return nome;
	}
	public void setNome(String nome) {
		this.nome = nome;
	}
	@XmlElement
	public int getAno() {
		return ano;
	}
	public void setAno(int ano) {
		this.ano = ano;
	}

	@XmlElement
	@XmlElementWrapper
	public List<Musica> getMusicas() {
		return musicas;
	}
	public void setMusicas(List<Musica> musicas) {
		this.musicas = musicas;
	}
}

Listagem 4: Classe Musica

public class Musica {

	private String nome;

	@XmlElement
	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}
}

Para realizar o exemplo deste artigo, é necessário que se tenha o servidor de aplicação JBoss AS7 instalado e configurado e a IDE eclipse para JEE. Vamos iniciar nossa aplicação criando um novo Dynamic Web Project chamando-o de musicApp, e informaremos à IDE que desejamos que gere o nosso Deployment Descriptor, conforme pode ser visto na figura 3. Após isso, clique em finish.

Criando um novo Dynamic Web Project

Figura 1: Criando um novo Dynamic Web Project

Configurando o Deployment Descriptor

Figura 2: Configurando o Deployment Descriptor

Antes de iniciar, configure o RESTEasy no Deployment Descriptor da aplicação. A Listagem 5 mostra o que deve ser adicionado no Deployment Descriptor para configuração do RESTEasy. Após isso, crie um pacote chamado domain, e adicione as classes Banda, Album e Musicas, exibidas logo acima.

Listagem 5: Configuração a ser adicionada no web.xml

<context-param>
    <param-name>resteasy.scan</param-name>
    <param-value>true</param-value>
  </context-param>
  <servlet>
    <servlet-name>resteasy-servlet</servlet-name>
    <servlet-class>
	org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher
</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>resteasy-servlet</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>

O próximo passo é criar a classe BandaService e um pacote chamado resource. Esta classe é a responsável por expor o serviço Rest, e pode ser vista na Listagem 6.

Listagem 6: Classe BandaService

@Path("/banda")
public class BandaService {
 
	@GET
	@Path("/get")
	@Produces("application/xml")
	public Banda getUserInXML() {
		
		Banda banda = new Banda();
		banda.setNome("Led Zeppelin");
		
		Album album = new Album();
		album.setAno(1969);
		album.setNome("Led Zeppelin");
		
		Musica musica1 = new Musica();
		Musica musica2 = new Musica();
		List<Musica> musicas = new ArrayList<Musica>();
		
		musica1.setNome("Good Times Bad Times");
		musica2.setNome("You Shook Me");
		musicas.add(musica1);
		musicas.add(musica2);
		
		album.setMusicas(musicas);
		banda.setAlbum(album);
		
		return banda; 
	}
}

Estamos quase lá. Agora só falta nossa classe cliente, a classe que consumirá o serviço. Para isso crie uma classe chamada de ClienteJava, conforme pode ser vista na Listagem 7. A estrutura da nossa aplicação pode ser vista na figura 3.

Listagem 7: Classe ClienteJava

public class ClienteJava {

	private static int HTTP_COD_SUCESSO = 200;

	public static void main(String[] args) throws JAXBException {

		try {

			URL url = new URL("http://localhost:8080/musicApp/banda/get");
			HttpURLConnection con = (HttpURLConnection) url.openConnection();

			if (con.getResponseCode() != HTTP_COD_SUCESSO) {
				throw new RuntimeException("HTTP error code : "+ con.getResponseCode());
			}

			BufferedReader br = new BufferedReader(new InputStreamReader((con.getInputStream())));
						
			JAXBContext jaxbContext = JAXBContext.newInstance(Banda.class);

			Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
			Banda banda = (Banda) jaxbUnmarshaller.unmarshal(br);
			
			System.out.println("------  Dados da Banda  -------- \n");
			System.out.println("Nome da Banda : "+banda.getNome());
			System.out.println("Nome do Álbum : "+banda.getAlbum().getNome());
			System.out.println("Ano de Lançamento: "+banda.getAlbum().getAno());
			
			int count = 1;
			
			for (Musica musica : banda.getAlbum().getMusicas()) {
				System.out.println("Música "+ count +": "+ musica.getNome());
				count++;	
			}

			con.disconnect();

		} catch (MalformedURLException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
Estrutura da aplicação musicApp

Figura 3: Estrutura da aplicação musicApp

Como a classe ClienteJava é a mais importante, objetivo de nosso artigo, vamos falar um pouco sobre ela. A parte mais interessante é logo após se obter o contexto do JAXB. A partir deste contexto, podemos criar um objeto Unmarsheller, permitindo converter o XML em objetos Java. Após isso, é passada a instância do BufferdReader obtida pelos dados retornados na conexão, sendo que o próprio JAXB obtem, por meio de um Cast explícito, uma instância do objeto Banda. Por fim, são exibidas no console as informações deste objeto.

Bom pessoal, espero que tenham gostado. Até um próximo post. Abraço.