Android + Servlet – Como criar um Servlet para tráfego de objetos com o Android

comunicacao

“Servlet (servidorzinho em tradução livre) é um componente como um servidor, que gera dados HTML e XML para a camada de apresentação de uma aplicação Web. É basicamente uma classe na linguagem de programação Java que dinamicamente processa requisições e respostas, proporcionando dessa maneira novos recursos aos servidores. A definição mais usada considera-os extensões de servidores. Servlet é um módulo que estende a funcionalidade de um servidor Web, através de módulos de aplicação implementados em Java.” (Wikipédia)

O objetivo desse post é mostrar como criar um Servlet para se comunicar via objetos com um cliente Android. No exemplo vou utilizar o NetBeans 7.3 com Glassfish e o Android com uma maquina virtual 4.2.2. O objetivo deste post não é explicar toda estrutura do Servlet, mas sim explicar a criação de um projeto simples que receba um objeto e retorne outro.

Vamos iniciar com a criação do Servlet:

1 – Crie um projeto Java Web.

1.1

2 – De um nome ao projeto e escolha seu destino.

1.2

3 – Nesta etapa vamos definir nesse servidor de contêiner, no caso o GlassFish, ele que vai ser responsável pela gerencia do projeto web. Veja que no context path o valor atribuído é o mesmo do nome do projeto, você pode altera-lo se quiser.

1.3

4 – Após o projeto ser criado, vamos criar o Servlet.

1.4

5 – De um nome ao seu Servlet e defina um package para ele. Pode clicar em Finish após isso.

1.5

Agora vamos iniciar a parte do desenvolvimento da parte do Servlet.

Vamos criar o objeto que deve ser trafegado no mesmo package do servlet (depois você pode ter uma organização melhor).

package com.wordpress.zarelli;

import java.io.Serializable;

/**
 *
 * @author guilherme
 */
public class ObTeste implements Serializable {

    public static final long serialVersionUID = 20120523113610L;
    private String teste;

    public ObTeste() {
        this("");
    }

    public ObTeste(String teste) {
        this.teste = teste;
    }

    public String getTeste() {
        return teste;
    }

    public void setTeste(String teste) {
        this.teste = teste;
    }

    @Override
    public String toString() {
        return "ObTeste{" + "teste=" + teste + '}';
    }
}

Depois da criação do objeto, vamos alterar a classe ‘exServlet.java’

Note essa linha:

@WebServlet(name = "exServlet", urlPatterns = {"/exServlet"})

o urlPatterns vai definir qual o link de acesso do servlet. No caso vamos acessa-lo desta maneira:

protocolo://ip:porta/projeto/servlet - ex: http://localhost:8080/exServlet/exServlet'

Agora vamos alterar o código para que ele possa receber e responder o objeto:

@WebServlet(name = "exServlet", urlPatterns = {"/exServlet"})
public class exServlet extends HttpServlet {

    /**
     * Processes requests for both HTTP
     * <code>GET</code> and
     * <code>POST</code> methods.
     *
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        //definimos o content type para application/binary para o trafego de objetos
        response.setContentType("application/binary");

        try {
            //abre o canal de entrada e saída
            ObjectInputStream ois = new ObjectInputStream(request.getInputStream());
            ObjectOutputStream oos = new ObjectOutputStream(response.getOutputStream());

            //recebe o objeto
            ObTeste obTeste = (ObTeste) ois.readObject();
            //altera um parametro
            obTeste.setTeste("respondendo");
            //responde
            oos.writeObject(obTeste);

            //fecha as conexões
            ois.close();
            oos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

Pronto nosso servidor está pronto. Clique com o botão direito em cima do projeto do servidor e clique em “Deploy” ou “Implementar”, essa ação realiza a implementação automatica para o Glassfish.

Segue a criação do projeto android:

1 – Crie um novo projeto Android:
(Para quem não tem o android no netbeans veja: http://goo.gl/dYqM0)

2.1

2 – Defina o nome do projeto e o package.

2.2

3 – Copie o ObTeste para esse projeto, note como deve ficar a estrutura dos projetos:

Lembre-se que o objeto que será trafegado deve ser IDÊNTICO ao que está no servidor, inclusive, estar no mesmo package. A forma mais correta de se fazer é criar uma biblioteca, porem vamos simplesmente copiar e colar.

3

Agora vamos implementar a comunicação diretamente na MainActivity, está não é a melhor solução, pois não estamos inserindo a comunicação em uma AsyncTask ou utilizando algum Handler para se comunicar com a interface. Como é só um teste vamos imprimir a saída diretamente no Log.

MainActivity.java:

public class MainActivity extends Activity {

    private static final String TAG = "com.wordpress.zarelli.MainActivity";

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        new Thread() {
            @Override
            public void run() {
                try {
                    //estou usando o ip 10.0.2.2 pois o emulador acessa sua
                    //maquina atravez dele.
                    URL url = new URL("http://10.0.2.2:8080/exServlet/exServlet");
                    HttpURLConnection http = (HttpURLConnection) url.openConnection();
                    http.setRequestMethod("POST");
                    http.addRequestProperty("content-type", "application/binary");
                    http.setDoInput(true);
                    http.setDoOutput(true);
                    http.setConnectTimeout(20000);

                    http.connect();
                    //abre canal de saída
                    ObjectOutputStream oos = new ObjectOutputStream(http.getOutputStream());
                    //envia objeto
                    oos.writeObject(new ObTeste("teste envio"));

                    //abre canal de leitura
                    ObjectInputStream ois = new ObjectInputStream(http.getInputStream());
                    //recebe objeto
                    Serializable obTeste = (Serializable) ois.readObject();
                    //imprime log
                    Log.i(TAG, "RETORNO:> " + obTeste.toString());

                } catch (Exception e) {
                    Log.e(TAG, "MainActivity.onCreate.servlet", e);
                }
            }
        }.start();
    }
}

Pronto,é só rodar que a comunicação será feita.

Link dos projetos: http://goo.gl/Kzu5a

Veja também:
AsyncTask: http://goo.gl/2poqS
Handler: http://goo.gl/IDDfh

Anúncios

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s