Aplicação J2ME para Iniciantes

Iremos aqui, trabalhar com uma aplicação j2ME que trabalha com Http Connection e Com RMS para entrada e armazenamento de dados. Valos lá!

Classe MIDLets.

  1. /* 
  2.  * 
  3.  * ControledeGastos.java 
  4.  * 
  5.  *
  6.  * 
  7.  */  
  8.   
  9. package midlet;  
  10.   
  11. import controleForm.AlteraFormulario;  
  12. import form.ComunicacaoServidorWeb;  
  13. import form.ReferenciaDespesas;  
  14. import form.RegistroDespesas;  
  15. import java.io.InputStream;  
  16. import javax.microedition.midlet.*;  
  17. import javax.microedition.lcdui.*;  
  18.   
  19. /** 
  20.  * 
  21.  *    Esta é a classe principal ou seja e o MIDLets propriamente dito, nele e onde temos o ciclo de vida do  
  22.  * MIDLets e por ele que manipulamos todo o aplicativo temos nela o método 
  23.  * “public void startApp()” que e o primeiro método a ser executado quando o aplicativo for aberto,  
  24.  * temos também o método “public void pauseApp()” que e solicitado quando tiver que interromper a  
  25.  * execução do aplicativo para fazer uma outra tarefa no aparelho como por exemplo atender uma ligação, 
  26.  * e temos o método “public void destroyApp(boolean unconditional)” que e executado quando esta sendo  
  27.  * fechado o aplicativo, são estes três métodos que compõem o ciclo de vida do MIDLets eles são  
  28.  * obrigatórios em um MIDLets. 
  29.  * Temos também o método “public void commandAction(Command c, Displayable s)” que e nele que pegamos  
  30.  * as ações efetuados pelo usuário. 
  31.  * E o método “private String lerArquivoHelp()” que e por ele que lemos o arquivo de HELP  
  32.  * que esta armazenado em uma arquivo (.TXT) 
  33.  * 
  34.  * 
  35.  */  
  36.   
  37. public class ControledeGastos extends MIDlet implements CommandListener {  
  38.      
  39.    private Display display = null;  
  40.    private Form formMaim   = null;  
  41.    private Ticker ticker   = null;   
  42.    private Image image     = null;  
  43.    private Alert alerta    = null;  
  44.    private Command commExit, commControleDeGasto,   
  45.            commDescricaoGasto, commLogin, commHelp;  
  46.    private AlteraFormulario alteraFormulario = null;  
  47.      
  48.      
  49.    public ControledeGastos(){  
  50.        display  = Display.getDisplay(this);  
  51.        formMaim = new Form( "Controle de Despesas" );  
  52.        formMaim.addCommand( commExit = new Command("Sair", Command.EXIT, 0) );  
  53.        formMaim.addCommand( commControleDeGasto = new Command( "Controle de Gasto", Command.OK, 1) );       
  54.        formMaim.addCommand( commDescricaoGasto = new Command( "Referência de Gasto",Command.OK, 1) );  
  55.        formMaim.addCommand( commLogin = new Command( "Acesso Servidor Web",Command.OK, 1) );  
  56.        formMaim.addCommand( commHelp = new Command( "Help",Command.HELP, 1) );  
  57.        formMaim.setTicker( ticker = new Ticker( "Ederson Thomazini, Fernando Schutz.MS & Adriano Sabo" ) );          
  58.        try{  
  59.          image = Image.createImage( "/imagem/Inicial.png" );  
  60.        }catch (Exception e) { }        
  61.        formMaim.append(new ImageItem( null, image, ImageItem.LAYOUT_CENTER, null) );  
  62.        formMaim.setCommandListener( this );       
  63.        alteraFormulario = AlteraFormulario.instancia(display, formMaim);   
  64.    }  
  65.   
  66. //******************************************************************************  
  67.      
  68.    public void startApp() {  
  69.       display.setCurrent(formMaim);  
  70.    }  
  71.       
  72.    public void pauseApp() { }  
  73.       
  74.    public void destroyApp(boolean unconditional) { }  
  75.   
  76. //******************************************************************************  
  77.      
  78.    public void commandAction(Command c, Displayable s){  
  79.       if (c == commExit){  
  80.          destroyApp(false);  
  81.          notifyDestroyed();     
  82.       }else if (c == commControleDeGasto){  
  83.          alteraFormulario.pushForm( new RegistroDespesas("Total R$:0.00", this, ticker) );        
  84.       }else if (c == commDescricaoGasto){  
  85.          alteraFormulario.pushForm( new ReferenciaDespesas("Referência de Despesas.", this, ticker));            
  86.       }else if (c== commLogin){  
  87.           alteraFormulario.pushForm( new ComunicacaoServidorWeb("Acesso Servidor Web.", this, ticker));   
  88.       }else if (c == commHelp) alerta(lerArquivoHelp(), formMaim);          
  89.     }      
  90.       
  91.    private String lerArquivoHelp(){  
  92.       try{  
  93.          int chr = 0;   
  94.          InputStream arquivoHelp = getClass().getResourceAsStream("/ajuda/Ajuda.Thomazini");  
  95.          StringBuffer stb = new StringBuffer();          
  96.          while ((chr = arquivoHelp.read())!= -1)  
  97.             stb.append((char)chr);  
  98.          return stb.toString();            
  99.       }catch (Exception e){  
  100.          alerta("Erro ao abrir o arquivo de ajuda!", formMaim);  
  101.       }   
  102.       return null;  
  103.    }    
  104.      
  105.     public AlteraFormulario alteraFormulario(){  
  106.         return alteraFormulario;  
  107.     }  
  108.       
  109.    public void alerta(String mensagem, Form frm){  
  110.       try{  
  111.          Image img = Image.createImage("/imagem/Duke.png");  
  112.          alerta = new Alert("Controle de Despesas", mensagem, img,null);     
  113.          alerta.setTicker(ticker);  
  114.          alerta.setTimeout(Alert.FOREVER);  
  115.          display.setCurrent(alerta, frm);  
  116.       }catch (Exception e){}        
  117.    }   
  118.      
  119. }  


Classe de manipulação de formulários.

  1. /* 
  2.  * AlteraFormulario.java 
  3.  * 
  4.  * 
  5.  * 
  6.  */  
  7.   
  8. package controleForm;  
  9.   
  10. import java.util.Stack;  
  11. import javax.microedition.lcdui.Display;  
  12. import javax.microedition.lcdui.Displayable;  
  13.   
  14. /** 
  15.  * 
  16.  * Esta classe tem como função alterar no display os formulários da aplicação,  
  17.  * quando e  dado um “new” e passado para ela o display do MIDLets e o formulário Principal,  
  18.  * quando for chamado o método “public void pushDisplayable(Displayable newDisplayable)”   
  19.  * e passado para ele a classe que tem o novo formulário com isso ela troca o formulário 
  20.  * principal com o que foi solicitado pelo usuário. 
  21.  *    Quando quiser voltar pro formulário principal e chamado o método 
  22.  * “ public void popDisplayable()” que retorna o formulário principal no display ou o formulario que esttiver 
  23.  *na vez de ser mostrado, ele trabalha em forma de pilha. 
  24.  *    
  25.  * 
  26.  * 
  27.  */  
  28.   
  29. public class AlteraFormulario extends Stack{  
  30.      
  31.    private Display      display = null;        
  32.    private Displayable mainForm = null;    
  33.    private static AlteraFormulario alteraFormulario = null;  
  34.      
  35.    private AlteraFormulario(Display display, Displayable mainForm){  
  36.       this.display = display;  
  37.       this.mainForm = mainForm;   
  38.    }     
  39.      
  40.    public static AlteraFormulario instancia(Display display, Displayable mainForm){  
  41.       if(alteraFormulario == null)  
  42.          alteraFormulario = new AlteraFormulario(display, mainForm);      
  43.      return alteraFormulario;  
  44.    }   
  45.      
  46.    public void pushForm(Displayable newForm){  
  47.       push(display.getCurrent());  
  48.       display.setCurrent(newForm);  
  49.    }   
  50.       
  51.    public void popForm(){  
  52.       if (empty() == false)  
  53.          display.setCurrent((Displayable) pop());  
  54.       else   
  55.          display.setCurrent(mainForm);  
  56.    }    
  57.      
  58. }  


Classe e a responsável por manipular os RMS .

  1. /* 
  2.  * ArmazenamentoPersistente.java 
  3.  * 
  4.  *
  5.  */  
  6.   
  7. package rms;  
  8.   
  9. import java.io.ByteArrayInputStream;  
  10. import java.io.ByteArrayOutputStream;  
  11. import java.io.DataInputStream;  
  12. import java.io.DataOutputStream;  
  13. import java.util.Vector;  
  14. import javax.microedition.rms.RecordEnumeration;  
  15. import javax.microedition.rms.RecordStore;  
  16.   
  17. /** 
  18.  * 
  19.  *   Esta classe e a responsável por manipular os RMS (Record Management System),  
  20.  * temos nela os seguintes métodos “public RecordStore openRecStore(String nome)”  
  21.  * que serve para abrir um RMS s ele já existir ele abre senão ele cria um armazém de  
  22.  * registros, temos também o método “public void closeRecStore(RecordStore rms)”  
  23.  * que serve para fechar um RMS, temos o método “public void deleteRecStore(String nome)”  
  24.  * que e o responsável por excluir um registro armazenado no RMS, e também o método  
  25.  * “public void gravarRegistro(RecordStore rms, String text)” que e o responsável por gravar  
  26.  * registros no RMS, temos outros métodos mas são semelhantes a estes citados que só muda os  
  27.  * parâmetros a serem passados a eles mas a funcionalidade e a mesma. 
  28.  * 
  29.  * 
  30.  * 
  31.  */  
  32.   
  33. public class ArmazenamentoPersistente {  
  34.       
  35.    private Vector                vetorGasto    = null;  
  36.    private ByteArrayInputStream  istrmBytes    = null;  
  37.    private DataInputStream       istrmDataType = null;  
  38.    private ByteArrayOutputStream ostrmBytes    = null;  
  39.    private DataOutputStream      ostrmDataType = null;    
  40.    private RecordEnumeration     numeroRms     = null;   
  41.    private OrdenaRms             ordenaRms     = null;  
  42.     
  43.    public ArmazenamentoPersistente() {  
  44.       vetorGasto = new Vector();      
  45.       ostrmBytes = new ByteArrayOutputStream();  
  46.       ostrmDataType = new DataOutputStream(ostrmBytes);   
  47.    }  
  48.           
  49.    public RecordEnumeration initEnumeration(RecordStore rms){             
  50.       try{  
  51.          if (rms.getNumRecords() > 0){  
  52.             ordenaRms = new OrdenaRms();            
  53.             numeroRms = rms.enumerateRecords(null, ordenaRms, false);  
  54.          }    
  55.       }catch (Exception e){System.out.println("Thomazini "+ e);}  
  56.       return numeroRms;  
  57.    }  
  58.      
  59.    public RecordStore openRecStore(String nome){  
  60.       try{        
  61.          return RecordStore.openRecordStore(nome, true);  
  62.       }catch (Exception e){return null;}  
  63.    }  
  64.      
  65.    public void closeRecStore(RecordStore rms){  
  66.       try{  
  67.          rms.closeRecordStore();  
  68.          ostrmBytes.close();  
  69.          ostrmDataType.close();  
  70.       }catch (Exception e){return;}           
  71.    }  
  72.     
  73.    public void deleteRecStore(String nome){  
  74.       try{  
  75.          RecordStore.deleteRecordStore(nome);  
  76.       }catch (Exception e){return;}  
  77.    }   
  78.      
  79.    public void gravarRegistro(RecordStore rms, String text){  
  80.       try{        
  81.          byte[] record;   
  82.          ostrmBytes.reset();  
  83.          ostrmDataType.writeUTF(text);  
  84.          ostrmDataType.flush();  
  85.          record = ostrmBytes.toByteArray();  
  86.          rms.addRecord(record, 0, record.length);            
  87.          ostrmBytes.reset();  
  88.       }catch (Exception e) {return;}        
  89.    }   
  90.      
  91.    public void gravarRegistro(RecordStore rms, String vDescricao, int vQnt, float vValor){  
  92.       int [] qnt = {vQnt};  
  93.       String[] descricao = {vDescricao};  
  94.       float[] valor = {vValor};  
  95.       gravarRms(rms, descricao,qnt,valor);  
  96.    }     
  97.      
  98.    private void gravarRms(RecordStore rms, String[] vDescricao,int[] vQnt, float[] vValor) {  
  99.       try {             
  100.          ostrmBytes.reset();      
  101.          byte[] record = null;        
  102.          for (int i = 0; i < vDescricao.length; i++){             
  103.             ostrmDataType.writeUTF(vDescricao[i]);  
  104.             ostrmDataType.writeInt(vQnt[i]);             
  105.             ostrmDataType.writeFloat(vValor[i]);  
  106.             ostrmDataType.flush();  
  107.             record = ostrmBytes.toByteArray();  
  108.             rms.addRecord(record, 0, record.length);              
  109.             ostrmBytes.reset();  
  110.          }  
  111.       }catch (Exception e) {return;}      
  112.    }      
  113.      
  114. }  


Classe para ordenar o RMS.

  1.    
  2.   
  3. /* 
  4.  * OrdenaRms.java 
  5.  * 
  6.  *
  7.  */  
  8.   
  9. package rms;  
  10.   
  11. import java.io.ByteArrayInputStream;  
  12. import java.io.DataInputStream;  
  13. import javax.microedition.rms.RecordComparator;  
  14.   
  15. /** 
  16.  *  
  17.  *   Esta e a classe responsável por fazer a ordenação dos dados dos registros,  
  18.  * ela contem os seguinte método  
  19.  * “public int compare(byte[] rec1, byte[] rec2)” que e o responsável por ordenar os dados informados   
  20.  * que no casso ordena em ordem alfabética, e temos também o método  
  21.  * “public void compareClose()” que e o responsável por finalizar o processo de ordenação. 
  22.  * 
  23.  *
  24.  * 
  25.  */  
  26.   
  27. public class OrdenaRms implements RecordComparator {  
  28.      
  29.    private byte[] record                  = null;    
  30.    private ByteArrayInputStream strmBytes = null;   
  31.    private DataInputStream strmDataType   = null;  
  32.       
  33.    public OrdenaRms() { }  
  34.      
  35.    public void compareClose(){  
  36.       try{  
  37.          if (strmBytes != null)  
  38.             strmBytes.close();  
  39.          if (strmDataType != null)  
  40.             strmDataType.close();  
  41.       }catch (Exception e){}  
  42.    }   
  43.      
  44.    public int compare(byte[] rec1, byte[] rec2){  
  45.       String valor1 = null, valor2 = null;  
  46.       try{        
  47.          int maxsize = Math.max(rec1.length, rec2.length);  
  48.          record = new byte[maxsize];        
  49.          strmBytes = new ByteArrayInputStream(rec1);  
  50.          strmDataType = new DataInputStream(strmBytes);        
  51.          valor1 = strmDataType.readUTF();        
  52.          strmBytes = new ByteArrayInputStream(rec2);  
  53.          strmDataType = new DataInputStream(strmBytes);       
  54.          valor2 = strmDataType.readUTF();        
  55.          int resultado = valor1.compareTo(valor2);  
  56.          if (resultado == 0)  
  57.             return RecordComparator.EQUIVALENT;  
  58.          else if (resultado < 0)  
  59.             return RecordComparator.PRECEDES;  
  60.          else  
  61.             return RecordComparator.FOLLOWS;  
  62.       }catch (Exception e){  
  63.          return RecordComparator.EQUIVALENT;  
  64.        }  
  65.    }    
  66. }  


Classe que será utilizada para cirar os objetos que serão manipulados no aplicativo.

  1. /* 
  2.  * ItemRms.java 
  3.  * 
  4.  *
  5.  */  
  6.   
  7. package rms;  
  8.   
  9. /** 
  10.  * 
  11.  *    Esta classe é a responsável por agrupar nela o descrição informada com o  
  12.  * ID da mesma armazenando os 2 em um objeto. Temos os seguintes métodos  
  13.  * “public void setText(String text)” que serve para trocar a descrição do item, temos também o método  
  14.  * “public String getText()” e o responsável para ler a descrição do item, temos também o método  
  15.  * “public int getRecordId()” que lê o numero do ID do item.. 
  16.  * 
  17.  *
  18.  * 
  19.  */   
  20.   
  21. public class ItemRms {  
  22.    private String texto;   
  23.    private int id;   
  24.    
  25.    public ItemRms(String texto, int id) {         
  26.       this.texto = texto;  
  27.       this.id = id;  
  28.    }  
  29.    public String getTexto(){  
  30.       return texto;  
  31.    }  
  32.      
  33.    public void setTexto(String texto){  
  34.       this.texto = texto;  
  35.    }    
  36.      
  37.    public int getId(){  
  38.       return id;  
  39.    }              
  40. }  


Classe Cadastro de Tipos de Gastos.

  1.    
  2.   
  3. /* 
  4.  * ReferenciaDespesas.java 
  5.  *
  6.  * 
  7.  */  
  8.   
  9. package form;  
  10.   
  11. import java.io.ByteArrayInputStream;  
  12. import java.io.ByteArrayOutputStream;  
  13. import java.io.DataInputStream;  
  14. import java.io.DataOutputStream;  
  15. import java.util.Vector;  
  16. import javax.microedition.lcdui.Alert;  
  17. import javax.microedition.lcdui.Choice;  
  18. import javax.microedition.lcdui.ChoiceGroup;  
  19. import javax.microedition.lcdui.Command;  
  20. import javax.microedition.lcdui.CommandListener;  
  21. import javax.microedition.lcdui.Displayable;  
  22. import javax.microedition.lcdui.Form;  
  23. import javax.microedition.lcdui.Item;  
  24. import javax.microedition.lcdui.ItemCommandListener;  
  25. import javax.microedition.lcdui.ItemStateListener;  
  26. import javax.microedition.lcdui.StringItem;  
  27. import javax.microedition.lcdui.TextField;  
  28. import javax.microedition.lcdui.Ticker;  
  29. import javax.microedition.rms.RecordEnumeration;  
  30. import javax.microedition.rms.RecordStore;  
  31. import midlet.ControledeGastos;  
  32. import rms.ArmazenamentoPersistente;  
  33. import rms.ItemRms;  
  34. import rms.OrdenaRms;  
  35.   
  36. /** 
  37.  * 
  38.  *    Esta e a classe que tem o formulário de Referência de gastos e nela que o usuário vai fazer o  
  39.  * cadastro de seus possíveis gastos, nela temos os seguintes métodos. 
  40.  * O método “protected void referencialistaVetor()” e o responsável por listar os dados que 
  41.  * estão no vetor e criar na telas os componentes que vão mostrar as referências cadastradas,  
  42.  * Temos também o método “private void referenciaOrdenaVetor(RecordStore rms)” este e o método que  
  43.  * lista o conteúdo do RMS e armazena dentro de um vetor para ficar mais fácil de manipular os dados,  
  44.  * temos o método “public void itemStateChanged(Item item)” que é onde nos pegamos os eventos dos  
  45.  * componentes (ChoiceGroup), temos o método “public void commandAction(Command c, Displayable d)”  
  46.  * que e onde pegamos os eventos do menu do aparelho e também o método  
  47.  * “public void commandAction(Command c, Item item)” que onde e pego o evento do botão. 
  48.  * 
  49.  *
  50.  * 
  51.  */  
  52.   
  53. public class ReferenciaDespesas extends Form implements ItemStateListener,   
  54.                                                         CommandListener,   
  55.                                                         ItemCommandListener {  
  56.    private Alert alertErro = null;  
  57.    private StringItem buttonGravar = null;  
  58.    private TextField tfDescricao = null;     
  59.    private Command commGravar    = null,   
  60.                      commExit    = null;                    
  61.    private Vector   vetorItem    = null;       
  62.    private ChoiceGroup cgItem    = null;      
  63.    private String REC_STORE_REFERENCIA_GASTO = null;    
  64.    private ByteArrayInputStream istrmBytes   = null;  
  65.    private DataInputStream istrmDataType     = null;    
  66.    private ByteArrayOutputStream ostrmBytes  = null;  
  67.    private DataOutputStream ostrmDataType    = null;     
  68.    private RecordEnumeration numeroRms  = null;   
  69.    private OrdenaRms ordenaRms          = null;   
  70.    private ControledeGastos frmControle = null;  
  71.    private RecordStore referenciaRms    = null;  
  72.    private ArmazenamentoPersistente referenciaGasto = null;        
  73.       
  74.       
  75.     public ReferenciaDespesas(String titulo,ControledeGastos frmControle, Ticker ticker) {  
  76.        super(titulo);  
  77.        this.frmControle = frmControle;  
  78.        vetorItem = new Vector();  
  79.        REC_STORE_REFERENCIA_GASTO = "rmsReferenciaGasto";  
  80.        referenciaRms =(referenciaGasto = new ArmazenamentoPersistente()).openRecStore(REC_STORE_REFERENCIA_GASTO);                 
  81.        buttonGravar = new StringItem("                              Gravar","", Item.BUTTON);  
  82.        buttonGravar.setDefaultCommand(commGravar = new Command("Gravar", Command.ITEM, 1));  
  83.        buttonGravar.setItemCommandListener(this);      
  84.        buttonGravar.setPreferredSize(235,10);          
  85.        setTicker(ticker);  
  86.        addCommand(commExit = new Command( "Sair", Command.EXIT, 1 ));          
  87.        append( tfDescricao = new TextField( "Descrição:","",80, TextField.ANY ));  
  88.        append( buttonGravar );   
  89.        append( cgItem = new ChoiceGroup( "", Choice.MULTIPLE ));  
  90.        setCommandListener(this);  
  91.        setItemStateListener(this);        
  92.        listarOrdenarRms( referenciaRms );    
  93.     }  
  94.       
  95.     private void listarOrdenarRms(RecordStore rms){  
  96.       try{  
  97.          referenciaOrdenaVetor(rms);  
  98.          referencialistaVetor();           
  99.       }catch (Exception e){  
  100.           msg("Ocorreu um erro na listagem dos registros armazenados!");       
  101.        }          
  102.    }   
  103.       
  104.    protected void referencialistaVetor(){  
  105.       try{  
  106.          for (int i = cgItem.size(); i > 0; i--)  
  107.             cgItem.delete(i - 1);  
  108.          ItemRms item;        
  109.          String texto;  
  110.          StringBuffer strb;  
  111.          for (int i = 0; i < vetorItem.size(); i++){  
  112.             item = (ItemRms) vetorItem.elementAt(i);        
  113.             texto = (item.getTexto());        
  114.             strb = new StringBuffer();  
  115.             strb.append(texto);       
  116.             cgItem.append(strb.toString(), null);  
  117.          }  
  118.       }catch (Exception e){  
  119.           msg("Erro ao listar os registros!");            
  120.        }  
  121.    }  
  122.      
  123.    private void referenciaOrdenaVetor(RecordStore rms){    
  124.       try{  
  125.          vetorItem.removeAllElements();  
  126.          byte[] recData = new byte[referenciaRms.getSize()];   
  127.          ByteArrayInputStream   istrmBytes = new ByteArrayInputStream(recData);  
  128.          DataInputStream   istrmDataType = new DataInputStream(istrmBytes);  
  129.          numeroRms = referenciaGasto.initEnumeration(rms);  
  130.          numeroRms.rebuild();  
  131.          while (numeroRms.hasNextElement()){          
  132.             istrmBytes.reset();         
  133.             int id = numeroRms.nextRecordId();  
  134.             rms.getRecord(id, recData, 0);            
  135.             ItemRms item = new ItemRms(istrmDataType.readUTF(), id);  
  136.             vetorItem.addElement(item);             
  137.          }  
  138.          istrmBytes.close();  
  139.          istrmDataType.close();  
  140.       }catch (Exception e){  
  141.           msg("Erro ao ordenar os registros!");   
  142.        }  
  143.    }  
  144.      
  145.    protected void gravar(){  
  146.       try{  
  147.       referenciaGasto.gravarRegistro(referenciaRms, tfDescricao.getString());  
  148.       tfDescricao.delete(0,tfDescricao.size());  
  149.       listarOrdenarRms(referenciaRms);  
  150.       }catch (Exception e){  
  151.           msg("Ocorreu uma falha na gravação do registro!");     
  152.        }  
  153.    }  
  154.      
  155.    public void itemStateChanged(Item item){  
  156.       ChoiceGroup cgGroup;     
  157.       cgGroup = (ChoiceGroup) item;  
  158.       boolean selected[] = new boolean[cgGroup.size()];  
  159.       cgGroup.getSelectedFlags(selected);    
  160.       for (int i = 0; i < cgGroup.size(); i++){  
  161.          if (selected[i]){          
  162.             ItemRms vItem = (ItemRms) vetorItem.elementAt(i);  
  163.             try{  
  164.                referenciaRms.deleteRecord(vItem.getId());  
  165.             }catch (Exception e){  
  166.                 msg("Erro ao excluir o registro!");     
  167.              }break;  
  168.          }  
  169.       }listarOrdenarRms(referenciaRms);  
  170.    }  
  171.      
  172.    public void commandAction(Command c, Displayable d){  
  173.       if (c == commExit){           
  174.          referenciaGasto.closeRecStore(referenciaRms);  
  175.          frmControle.alteraFormulario().popForm();  
  176.       }  
  177.    }  
  178.      
  179.    public void commandAction(Command c, Item item) {    
  180.       if (item == buttonGravar)  
  181.          if (tfDescricao.size() != 0){gravar();}                   
  182.    }  
  183.      
  184.    private void msg(String msg){  
  185.       frmControle.alerta(msg, this);      
  186.    }   
  187. }  


Cadastro de Gastos.
  1. /* 
  2.  * RegistroDespesas.java 
  3.  * 
  5.  * 
  6.  */  
  7.   
  8. package form;  
  9.   
  10. import java.io.ByteArrayInputStream;  
  11. import java.io.ByteArrayOutputStream;  
  12. import java.io.DataInputStream;  
  13. import java.io.DataOutputStream;  
  14. import java.util.Vector;  
  15. import javax.microedition.lcdui.Alert;  
  16. import javax.microedition.lcdui.Choice;  
  17. import javax.microedition.lcdui.ChoiceGroup;  
  18. import javax.microedition.lcdui.Command;  
  19. import javax.microedition.lcdui.CommandListener;  
  20. import javax.microedition.lcdui.Displayable;  
  21. import javax.microedition.lcdui.Form;  
  22. import javax.microedition.lcdui.Item;  
  23. import javax.microedition.lcdui.ItemCommandListener;  
  24. import javax.microedition.lcdui.ItemStateListener;  
  25. import javax.microedition.lcdui.StringItem;  
  26. import javax.microedition.lcdui.TextField;  
  27. import javax.microedition.lcdui.Ticker;  
  28. import javax.microedition.rms.RecordEnumeration;  
  29. import javax.microedition.rms.RecordStore;  
  30. import midlet.ControledeGastos;  
  31. import rms.ArmazenamentoPersistente;  
  32. import rms.ItemRms;  
  33. import rms.OrdenaRms;  
  34.   
  35. /** 
  36.  * 
  37.  *    Esta e a classe que tem o formulário de Controle de gastos e nela que o usuário vai fazer  
  38.  * o cadastro de seus gastos, nela temos os seguintes métodos. 
  39.  * O método “protected ChoiceGroup getcgReferencia()” que é o responsável por criar o componente  
  40.  * (ChoiceGroup) que vai conter os dados do RMS de Referência de gastos, temos também o método  
  41.  * “protected void cgReferenciaItem()”que é  o responsável por listas todos os registro que estão no  
  42.  * RMS Referência de gastos no componente (ChoiceGroup), e temos o método  
  43.  * “protected void despesasListarVetor()” que e o responsável por listar os dados que estão no vetor  
  44.  * e criar os componentes para exibição dos gastos cadastrados, e o método  
  45.  * “protected void despesasOrdenaVetor(RecordStore rms)” e o responsável por listar os dados do  
  46.  * RMS no vetor ele percorre todo o armazém de registro e grava dentro do vetor para ficar mais 
  47.  * melhor a manipulação destes dados, temos o método “public void itemStateChanged(Item item)” 
  48.  * que é onde nos pegamos os eventos dos  
  49.  * componentes (ChoiceGroup), temos o método “public void commandAction(Command c, Displayable d)”  
  50.  * que e onde pegamos os eventos do menu do aparelho e também o método  
  51.  * “public void commandAction(Command c, Item item)” que onde e pego o evento do botão. 
  52.  * 
  53.  *
  54.  * 
  55.  */  
  56.   
  57. public class RegistroDespesas extends Form implements ItemStateListener,   
  58.                                                       CommandListener,   
  59.                                                       ItemCommandListener{  
  60.    private Alert alertErro;     
  61.    private ChoiceGroup cgItem;   
  62.    private StringItem buttonGravar;    
  63.    private ControledeGastos frmControle;   
  64.    private ChoiceGroup cgReferenciaGasto;  
  65.    private TextField tfValor,tfQnt;   
  66.    private Command commExit, commGravar;  
  67.    private Vector vetorDespesa;   
  68.    private float total;  
  69.    private String REC_STORE_REFERENCIA_GASTO;    
  70.    private String REC_STORE_REGISTRO_DESPESAS;    
  71.    private ByteArrayInputStream istrmBytes;  
  72.    private DataInputStream istrmDataType;    
  73.    private ByteArrayOutputStream ostrmBytes;  
  74.    private DataOutputStream ostrmDataType;     
  75.    private RecordEnumeration numeroRms;   
  76.    private OrdenaRms ordenaRms;   
  77.    private RecordStore referenciaRms, registoDespesasRms;  
  78.    private ArmazenamentoPersistente referenciaGasto,registoDespesas;   
  79.      
  80.     public RegistroDespesas(String titulo,ControledeGastos frmControle, Ticker ticker) {  
  81.       super(titulo);  
  82.       this.frmControle = frmControle;      
  83.       setTicker(ticker);  
  84.       vetorDespesa = new Vector();  
  85.       REC_STORE_REFERENCIA_GASTO = "rmsReferenciaGasto";  
  86.       REC_STORE_REGISTRO_DESPESAS = "rmsRegistroGasto";      
  87.       referenciaRms = (referenciaGasto = new ArmazenamentoPersistente()).openRecStore(REC_STORE_REFERENCIA_GASTO);    
  88.       registoDespesasRms = (registoDespesas = new ArmazenamentoPersistente()).openRecStore(REC_STORE_REGISTRO_DESPESAS);       
  89.       buttonGravar = new StringItem("                              Gravar","",Item.BUTTON);  
  90.       buttonGravar.setDefaultCommand( commGravar = new Command("Gravar",Command.ITEM, 1) );  
  91.       buttonGravar.setItemCommandListener(this);      
  92.       buttonGravar.setPreferredSize(235,10);      
  93.       addCommand( commExit = new Command("Sair.",Command.EXIT, 1) );            
  94.       append( tfQnt = new TextField("Quantidade.:","", 10, TextField.NUMERIC) );        
  95.       append( tfValor = new TextField("Valor Gasto:","",10, TextField.DECIMAL) );        
  96.       getcgReferencia();  
  97.       append(cgReferenciaGasto);              
  98.       append(buttonGravar);         
  99.       append(cgItem = new ChoiceGroup("", Choice.MULTIPLE));     
  100.       cgReferenciaItem();  
  101.       listarOrdenarRms(registoDespesasRms);   
  102.       setCommandListener(this);   
  103.       setItemStateListener(this);   
  104.     }  
  105.       
  106.     private void listarOrdenarRms(RecordStore rms){  
  107.       try{  
  108.          despesasOrdenaVetor(rms);  
  109.          despesasListarVetor();        
  110.       }catch (Exception e){  
  111.           msg("Ocorreu um erro na listagem dos registros armazenados!");  
  112.        }          
  113.    }   
  114.     
  115.    private void gravar(){  
  116.       try{            
  117.          registoDespesas.gravarRegistro(registoDespesasRms, cgReferenciaGasto.getString(cgReferenciaGasto.getSelectedIndex()),  
  118.                                         Integer.parseInt(tfQnt.getString()), Float.parseFloat(tfValor.getString()));             
  119.          tfValor.delete(0,tfValor.size());  
  120.          tfQnt.delete(0, tfQnt.size());             
  121.          cgReferenciaGasto.setSelectedIndex(0,true);  
  122.          listarOrdenarRms(registoDespesasRms);          
  123.       }catch (Exception e){  
  124.           msg("Ocorreu uma falha na gravação do registro!");  
  125.        }        
  126.   }  
  127.      
  128.    protected ChoiceGroup getcgReferencia() {  
  129.       if (cgReferenciaGasto == null) {                
  130.          cgReferenciaGasto = new ChoiceGroup("Referência..:", Choice.POPUP,new String[]{""},null);           
  131.       }return cgReferenciaGasto;        
  132.    }  
  133.      
  134.    protected void cgReferenciaItem(){    
  135.       try{       
  136.          byte[] recData = new byte[referenciaRms.getSize()];   
  137.          ByteArrayInputStream   istrmBytes = new ByteArrayInputStream(recData);  
  138.          DataInputStream   istrmDataType = new DataInputStream(istrmBytes);  
  139.          numeroRms = referenciaGasto.initEnumeration(referenciaRms);  
  140.          numeroRms.rebuild();  
  141.          while (numeroRms.hasNextElement()){          
  142.             istrmBytes.reset();         
  143.             int id = numeroRms.nextRecordId();  
  144.             referenciaRms.getRecord(id, recData, 0);            
  145.             ItemRms item = new ItemRms(istrmDataType.readUTF(), id);  
  146.             cgReferenciaGasto.append(item.getTexto(),null);                      
  147.          }  
  148.          istrmBytes.close();  
  149.          istrmDataType.close();  
  150.       }catch (Exception e){  
  151.           msg("Ocorreu um erro na listagem dos dados de referência!");  
  152.        }  
  153.    }   
  154.     
  155.    protected void despesasListarVetor(){  
  156.       try{      
  157.          for (int i = cgItem.size(); i > 0; i--)  
  158.             cgItem.delete(i - 1);  
  159.          ItemRms item;       
  160.          String text;  
  161.          StringBuffer strb;      
  162.          for (int i = 0; i < vetorDespesa.size(); i++){  
  163.             item = (ItemRms) vetorDespesa.elementAt(i);        
  164.             text = item.getTexto();        
  165.             strb = new StringBuffer();  
  166.             strb.append(text);        
  167.             cgItem.append(strb.toString(), null);  
  168.          }  
  169.       }catch (Exception e){  
  170.           msg("Erro ao listar os registros!");     
  171.        }  
  172.    }  
  173.      
  174.    protected void despesasOrdenaVetor(RecordStore rms) {     
  175.       try{  
  176.          total = 0;  
  177.          vetorDespesa.removeAllElements();  
  178.          byte[] recData = new byte[rms.getSize()];   
  179.          ByteArrayInputStream   istrmBytes = new ByteArrayInputStream(recData);  
  180.          DataInputStream   istrmDataType = new DataInputStream(istrmBytes);  
  181.          numeroRms = registoDespesas.initEnumeration(rms);   
  182.          numeroRms.rebuild();            
  183.          while (numeroRms.hasNextElement()){          
  184.             istrmBytes.reset();         
  185.             int id = numeroRms.nextRecordId();  
  186.             rms.getRecord(id, recData, 0);                
  187.             String vDesc = istrmDataType.readUTF();  
  188.             int vQuant = istrmDataType.readInt();              
  189.             float vValor = istrmDataType.readFloat();              
  190.             total = total + vValor;             
  191.             ItemRms item = new ItemRms (" " + vQuant + "-" + vDesc +"  R$: "+ vValor, id);  
  192.             vetorDespesa.addElement(item);  
  193.          }  
  194.         
  195.       }catch (Exception e){  
  196.           msg("Erro ao ordenar os registros!");     
  197.        }setTitle("Total R$: "+ total);  
  198.    }  
  199.      
  200.    public void itemStateChanged(Item item){  
  201.       if (item != cgReferenciaGasto){   
  202.          ChoiceGroup cgGroup;     
  203.          cgGroup = (ChoiceGroup) item;  
  204.          boolean selected[] = new boolean[cgGroup.size()];  
  205.          cgGroup.getSelectedFlags(selected);    
  206.          for (int i = 0; i < cgGroup.size(); i++){  
  207.             if (selected[i]){          
  208.                ItemRms vItem = (ItemRms) vetorDespesa.elementAt(i);  
  209.                try{  
  210.                   registoDespesasRms.deleteRecord(vItem.getId());  
  211.                }catch (Exception e){  
  212.                    msg("Erro ao excluir o registro!");  
  213.                 }break;  
  214.             }  
  215.          }listarOrdenarRms(registoDespesasRms);              
  216.       }  
  217.    }  
  218.    public void commandAction(Command c, Displayable s){  
  219.       if (c == commExit){  
  220.           referenciaGasto.closeRecStore(referenciaRms);  
  221.           registoDespesas.closeRecStore(registoDespesasRms);  
  222.          frmControle.alteraFormulario().popForm();  
  223.       }  
  224.    }      
  225.      
  226.    public void commandAction(Command c, Item item) {       
  227.       if (item == buttonGravar)  
  228.          if (cgReferenciaGasto.size() != 0){   
  229.             if (!validaCampoObrigatorio())  
  230.                gravar();  
  231.          }     
  232.    }  
  233.      
  234.    private boolean validaCampoObrigatorio(){  
  235.       boolean result;        
  236.       if(result = tfQnt.size() == 0){  
  237.          msg("Quantidade campo obrigatório");     
  238.       }else if (result = tfValor.size() == 0){  
  239.             msg("Valor campo obrigatório");  
  240.          }else if (result = cgReferenciaGasto.getString(cgReferenciaGasto.getSelectedIndex()) == "")  
  241.                msg("Referência campo obrigatório");   
  242.              
  243.       return result;      
  244.    }     
  245.   
  246.    private void msg(String msg){  
  247.       frmControle.alerta(msg, this);      
  248.    }    
  249.      
  250. }  


Classe para a entrada de login e senha para o servidor.
  1.    
  2.   
  3. /* 
  4.  * ComunicacaoServidorWeb.java 
  5.  * 
  6.   
  7.   
  8. package form;  
  9.   
  10. import conexao.ConexaoHttp;  
  11. import java.io.ByteArrayInputStream;  
  12. import java.io.DataInputStream;  
  13. import java.util.Vector;  
  14. import javax.microedition.io.HttpConnection;  
  15. import javax.microedition.lcdui.Command;  
  16. import javax.microedition.lcdui.CommandListener;  
  17. import javax.microedition.lcdui.Displayable;  
  18. import javax.microedition.lcdui.Form;  
  19. import javax.microedition.lcdui.Image;  
  20. import javax.microedition.lcdui.ImageItem;  
  21. import javax.microedition.lcdui.TextField;  
  22. import javax.microedition.lcdui.Ticker;  
  23. import javax.microedition.rms.RecordEnumeration;  
  24. import javax.microedition.rms.RecordStore;  
  25. import midlet.ControledeGastos;  
  26. import rms.ArmazenamentoPersistente;  
  27.   
  28. /** 
  29.  * 
  30.  *    Esta classe tem a função de solicitar ao usuário o Login e senha para fazer a conexão  
  31.  * com um servidor web, feito isso será disparado uma Thread que é pelo método “run()”  
  32.  * que e tratado os eventos,   O método “public void commandAction(Command c, Displayable s)” 
  33.  * é onde e pego os eventos dos componentes e passado para o método run() que processa o comando solicitado. 
  34.  * O método “private boolean enviaRMS(RecordStore rms)” e usado quando for pedido pra fazer  
  35.  * o envio dos dados para o servidor web e nele que é percorrido tudo o RMS (Record Management System)  
  36.  * e enviado para o servidor, quando os dados chegarem lá o responsável pelo processamento  
  37.  * e o Servlets que atualiza o banco de dados correspondente. 
  38.  * 
  39.  *
  40.  * 
  41.  * 
  42.  */  
  43.   
  44. public class ComunicacaoServidorWeb extends Form implements CommandListener, Runnable {  
  45.       
  46.    private ControledeGastos frmLogin = null;  
  47.    private Command commVoltar = null,  
  48.                    commLogin  = null,   
  49.                    commEnviar = null;  
  50.    private TextField tfLogin  = null,   
  51.                      tfSenha  = null,   
  52.                      tfUrl    = null;  
  53.    private RecordEnumeration numeroRms = null;   
  54.    private ArmazenamentoPersistente registoDespesas = null;      
  55.    private Thread commThread   = null;  
  56.    private HttpConnection http = null;  
  57.    private Command commCaptura = null;  
  58.    private ConexaoHttp conexaoServer = null;  
  59.    private String REC_STORE_REGISTRO_DESPESAS = null;  
  60.    private RecordStore registoDespesasRms     = null;  
  61.       
  62.    public ComunicacaoServidorWeb(String titulo, ControledeGastos frmLogin, Ticker ticker) {  
  63.       super(titulo);  
  64.       this.frmLogin = frmLogin;  
  65.       setTicker(ticker);  
  66.       REC_STORE_REGISTRO_DESPESAS = "rmsRegistroGasto";  
  67.       registoDespesasRms = (registoDespesas = new ArmazenamentoPersistente()).openRecStore(REC_STORE_REGISTRO_DESPESAS);        
  68.          
  69.       append(tfUrl = new TextField("URL","http://localhost:8080/Servlet/GetNpostServlet",200, TextField.URL));  
  70.       append(tfLogin = new TextField("Usuário", "",20, TextField.ANY));  
  71.       append(tfSenha = new TextField("Senha", "",20, TextField.PASSWORD));       
  72.       addCommand(commVoltar = new Command("Sair",Command.EXIT,1));  
  73.       addCommand(commLogin = new Command("Acessar",Command.OK,1));  
  74.          
  75.       try{  
  76.          Image image = Image.createImage("/imagem/jug_patch.gif");  
  77.          append(new ImageItem(null,image,ImageItem.LAYOUT_CENTER,null));  
  78.       }catch (Exception e) {}            
  79.       setCommandListener(this);  
  80.    }  
  81.      
  82.     public void commandAction(Command c, Displayable s){  
  83.       synchronized (this) {  
  84.          if (commThread != null) {return;}  
  85.          commCaptura = c;  
  86.          commThread = new Thread(this);  
  87.          commThread.start();  
  88.       }      
  89.    }  
  90.       
  91.    public void run() {          
  92.       if (commCaptura == commVoltar) {  
  93.          frmLogin.alteraFormulario().popForm();     
  94.       } else if (commCaptura == commLogin) {                       
  95.            try{  
  96.              conexaoServer = new ConexaoHttp(tfUrl.getString());   
  97.              if (conexaoServer.processoRmsPOST(("status=login"+  
  98.                                                 "&login=" + tfLogin.getString()+   
  99.                                                 "&senha=" + tfSenha.getString()).getBytes())){           
  100.                  if (conexaoServer.retornoConexao().equals(""))   
  101.                     msg("Usuário/Senha Inválido(s)");  
  102.                  else{  
  103.                      if(commEnviar == null)                       
  104.                         addCommand(commEnviar = new Command("Enviar",Command.OK,1));   
  105.                      msg("Seja bem vindo Sr.(a): " + conexaoServer.retornoConexao());                      
  106.                  }  
  107.               }else msg("Falha na autenticação do Login!");  
  108.            }finally{conexaoServer = null;}  
  109.         }else if (commCaptura == commEnviar){  
  110.             try{   
  111.                conexaoServer = new ConexaoHttp(tfUrl.getString());   
  112.                enviaRMS(registoDespesasRms);                 
  113.            }finally{  
  114.                removeCommand(commEnviar);  
  115.                conexaoServer = null;  
  116.             }  
  117.         }           
  118.        synchronized (this) {commThread = null;}  
  119.    }  
  120.      
  121.    private void enviaRMS(RecordStore rms){   
  122.       try{          
  123.          byte[] recData = new byte[rms.getSize()];   
  124.          ByteArrayInputStream   istrmBytes = new ByteArrayInputStream(recData);  
  125.          DataInputStream   istrmDataType = new DataInputStream(istrmBytes);  
  126.          numeroRms = registoDespesas.initEnumeration(rms);   
  127.          numeroRms.rebuild();            
  128.          try{          
  129.             while (numeroRms.hasNextElement()){          
  130.                istrmBytes.reset();         
  131.                int id = numeroRms.nextRecordId();              
  132.                rms.getRecord(id, recData, 0);   
  133.                conexaoServer.processoRmsPOST(("status="+conexaoServer.retornoConexao()+  
  134.                                              "&desc="+String.valueOf(istrmDataType.readUTF())+  
  135.                                              "&qnt="+String.valueOf(istrmDataType.readInt())+  
  136.                                              "&valor="+String.valueOf(istrmDataType.readFloat())+  
  137.                                              "&id="+String.valueOf(id)).getBytes());                                          
  138.            }            
  139.            msg("Transferência efetuada com sucesso!");  
  140.         }finally {  
  141.            istrmBytes.close();  
  142.            istrmDataType.close();   
  143.         }      
  144.      }catch (Exception e){  
  145.         msg("Problemas no envio do arquivo!");        
  146.       }  
  147.    }  
  148.     
  149.    private void msg(String msg){  
  150.       frmLogin.alerta(msg, this);      
  151.    }  
  152.      
  153. }  


Classe que faz a conexão com o servidor.

  1. /* 
  2.  * ConexaoHttp.java 
  3.  * 
  4.  *
  5.  * 
  6.  */  
  7.   
  8. package conexao;  
  9.   
  10. import java.io.ByteArrayOutputStream;  
  11. import java.io.IOException;  
  12. import java.io.InputStream;  
  13. import java.io.OutputStream;  
  14. import javax.microedition.io.Connector;  
  15. import javax.microedition.io.HttpConnection;  
  16.   
  17. /** 
  18.  * 
  19.  *    Esta classe tem como função fazer a conexão com o servidor web, é por ela que é enviado as solicitações  
  20.  * de login e também os dados do RMS. 
  21.  * O metodo “public boolean processoRmsPOST(byte[] dados)”  
  22.  * que é o responsável por fazer toda a parte de solicitações com o servidor, como: enviar os dados do RMS para o servidor web e fazer login e o método  
  23.  * “private boolean processServerResponse(HttpConnection  httpConexao, InputStream dados)”   
  24.  * ele que processa o retorno do servidor se tiver alguma informação vindo do servidor para o  
  25.  * aparelho é nele que é tratado. 
  26.  * 
  27.  * 
  28.  * 
  29.  */  
  30.   
  31. public class ConexaoHttp {  
  32.      
  33.    private String url    = null;  
  34.    private String result = null;  
  35.       
  36.    public ConexaoHttp(String url){  
  37.       this.url = url;  
  38.    }  
  39.      
  40.    public boolean processoRmsPOST(byte[] dados)  {      
  41.       HttpConnection httpConexao = null;  
  42.       OutputStream oStrm = null;  
  43.       InputStream iStrm = null;      
  44.       boolean valorRetorno = false;            
  45.       try{          
  46.          try{  
  47.        httpConexao = (HttpConnection)Connector.open(this.url);  
  48.        httpConexao.setRequestMethod(HttpConnection.POST);   
  49.             httpConexao.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");//Esta linha e obrigatoria para o metodo POS, isso indica que os dados estão indo separados da URL.            
  50.             oStrm = httpConexao.openOutputStream();  
  51.        oStrm.write(dados);//        
  52.        iStrm = httpConexao.openInputStream();  
  53.        valorRetorno =  processServerResponse(httpConexao, iStrm);  
  54.     }finally{  
  55.         if (iStrm != null) iStrm.close();  
  56.         if (oStrm != null)   oStrm.close();  
  57.              if (httpConexao != null) httpConexao.close();  
  58.      }if (valorRetorno == false){}  
  59.       }catch(Exception e){}  
  60.       return valorRetorno;        
  61.    }  
  62.      
  63.    private boolean processServerResponse(HttpConnection  httpConexao, InputStream dados) throws IOException {  
  64.        result = "";   
  65.        if ( httpConexao.getResponseCode() == HttpConnection.HTTP_OK ) {  
  66.          String urlNew = httpConexao.getHeaderField("Custom-newURL");           
  67.          if (urlNew != null)   
  68.             this.url = urlNew;  
  69.          int length = (int) httpConexao.getLength();  
  70.        String str = "";            
  71.        if (length != -1) {          
  72.           byte servletData[] = new byte[length];                
  73.           dados.read(servletData);  
  74.                str = new String(servletData);    
  75.        }else{  
  76.            ByteArrayOutputStream bStrm = new ByteArrayOutputStream();//isso serve para que quando tiver um retorno muito grande ele vai lendo e armazenando em uma array de bytes.         
  77.       int posicao = 0;  
  78.       while ((posicao = dados.read()) != -1) {  
  79.          bStrm.write(posicao);  
  80.          str = new String(bStrm.toByteArray());  
  81.          bStrm.close();  
  82.                 }  
  83.         }result = str;  
  84.          return true;           
  85.       }else return false;  
  86.    }  
  87.      
  88.    public String retornoConexao(){   
  89.       return result;  
  90.    }  
  91. } ]
    92.
  92.  É isso ai galera espero que tenham gostado e brevemente teremos mais. Até a próxima! De seu sempre amigo Bruno Rafael.

Comentários

Postar um comentário

Postagens mais visitadas deste blog

E Esse Tal de Nano Service?

Imagem
  Ao longo dos anos, o desenvolvimento de software se afastou das arquiteturas monolíticas tradicionais, abordando suas complexidades com código fortemente acoplado e interconectado. Isso resultou na adoção de microsserviços, abordagens eficientes nativas da nuvem que permitem a computação distribuída por meio de vários serviços menores. Desde que os microsserviços se tornaram mainstream, nos últimos anos, os nanoservices evoluíram como outro padrão que foi projetado principalmente para superar as complexidades encontradas nos microsserviços. Essencialmente, os nanoserviços dividem ainda mais os serviços para trazer eficiência adicional. Este artigo descreve como o desenvolvimento de componentes menores para criar um aplicativo é uma abordagem preferencial, portanto: Explicar micro e nanoserviços Explore benefícios e desafios Compartilhe exemplos e práticas recomendadas para ajudá-lo a determinar a estrutura certa para suas necessidades Melhorando as práticas de desenvolvimento Dev...
Leia mais

Executar Audio em Java Swing

Imagem
Uma das coisas que mais motivam nós programadores quando estamos aprendendo a programar ou que continuemos a estudar a linguagem a qual programamos é aprender sempre algo novo que a linguagem nos oferece. Claro que Java nos permite hoje fazer qualquer tipo de aplicação, porém o grande problema é que não sabemos como fazer o que queremos e a partir da aí buscamos cada vez mais o conhecimento que precisamos para fazer o que desejamos. Recentemente descobri essa biblioteca chamada  JLayer  a qual nos permite tocar de forma muito fácil arquivos MP3 em nossos programas Java. Eu ainda não estudei essa biblioteca profundamente para ver tudo o que ela tem, porém hoje eu mostro como fazer o básico para tocar arquivos MP3 usando a Jlayer. O tutorial é dividido em duas partes. A primeira parte (logo a seguir) ensina a tocar um arquivo mp3 em código Java de forma bem simples. Na segunda parte (que publicarei algum dia), ensinarei a tocar o arquivo mp3 usando threads e mostrando alguns o...
Leia mais

FTP em Java

Imagem
Fala galera! Esta próxima dica é bastante útil para quem pretende se conectar a servidores ftp, assim como enviar e efetuar downloads de arquivos! Vamos lá Primeiramente vamos entender oque é o Ftp e qual sua particularidade. File Transfer Protocol (FTP)  é um padrão de protocolo de rede usado para transferir arquivos de um  hospedeiro  para outro host em um  TCP   baseado em rede, como a  Internet  . Ele é frequentemente usado para carregar páginas da Web e outros documentos de uma máquina de desenvolvimento privada para um servidor público. FTP é construído sobre um  cliente-servidor  e usa arquitetura de controle separado e conexões de dados entre o cliente eo servidor.  usuários FTP podem se autenticar usando um  texto  sinal em protocolo, normalmente na forma de um nome de usuário e senha , mas pode ligar anonimamente, se o servidor está configurado para permitir isso. Para a transmissão se...
Leia mais