Emulador de Terminal Linux com a classe Java Runtime

Neste artigo veremos como usar a classe Runtime para construir um emulador de terminal linux. Nosso projeto ser� constru�do com base nos seguintes requisitos:

Possibilitar ao usu�rio executar comandos no emulador de terminal e obter a sa�da destes;
Possibilitar a visualizaç�o de hist�ricos dos comandos j� executados, possibilitando a escolha de um destes para execuç�o;
Mostrar erros de sa�da caso o comando executado seja inv�lido, colorindo a sa�da de vermelho quando ERRO e preto quando executado corretamente;
Possibilitar a execuç�o dos comandos atrav�s da tecla de atalho F5 para agilizar e facilitar o uso;
Possibilitar a limpeza dos hist�ricos dos comandos j� executados.

Nosso projeto consistir� de tr�s Classes, que s�o:

TerminalEmulator: Ser� a classe �core� respons�vel por executar os comandos no terminal real do Linux, capturando seus retornos e realizando os tratamentos necess�rios;
Fterminal: Formul�rio que far� a interface entre o usu�rio e a classe TerminalEmulator;
Dhistory: Mostrar� os hist�ricos de comandos j� executados possibilitando a seleç�o e re-execuç�o de qualquer comando a qualquer momento.

TerminalEmulator

Vamos começar nosso estudo atrav�s da classe que de fato faz todo trabalho �rduo, executando os comandos e cuidando dos hist�ricos de comando.

Vejamos ela por completa na Listagem 1.


  package br.com.lab;
   
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
   
  public class TerminalEmulator {
           
    private static List<String> commandHistory = new ArrayList<String>();

    public static Map<String, String> exec(String command) {
       Process proc = null;
       Map<String, String> result = new HashMap<String, String>();
       try {
          proc = Runtime.getRuntime().exec(command);

          result.put("input", inputStreamToString(proc.getInputStream()));
          result.put("error", inputStreamToString(proc.getErrorStream()));                         

       } catch (IOException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
          result.put("error", e.getCause().getMessage());  
       } finally{
          commandHistory.add(command);
       }

       return result;
    }

    private static String inputStreamToString(InputStream isr) {

       try {

          BufferedReader br = new BufferedReader(new InputStreamReader(isr));
          StringBuilder sb = new StringBuilder();
          String s = null;

          while ((s = br.readLine()) != null) {
                    sb.append(s + "\n");
          }

          return sb.toString();

       } catch (IOException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
          return null;
       }
    }

    public static void clearHistory(){
       commandHistory.clear();
    }

    public static List<String> getCommandHistory() {
       return commandHistory;
    }
  }

Listagem 1. TerminalEmulator.java

Toda vez que um comando for executado, seja ele errado ou certo, ele ser� gravado na lista 'commandHistory':


private static List<String> commandHistory = new ArrayList<String>();

O m�todo getCommandHistory() possibilita que o hist�rico de comandos possa ser recuperado de outros pontos do sistema e o m�todo clearHistory() faz a limpeza de todos os hist�ricos. Perceba que este possui a palavra reservada �static�, ou seja, seu estado ser� mantido enquanto a aplicaç�o estiver em execuç�o.

O m�todo mais importante de todos � o �exec()�, pois � ele quem vai executar o comando no terminal real, ou seja, o terminal do Linux. O exec() retorna um Map contendo sempre a chave �input� e a chave �error�. A chave �input� cont�m o conte�do retornando quando a execuç�o for bem-sucedida, enquanto a chave �error� retorna o conte�do de erro, quando houver.

A linha que faz tudo funcionar �:


proc = Runtime.getRuntime().exec(command);

Esta captura a inst�ncia de Runtime e chama o m�todo �exec()�, passando o comando desejado (ex: 'ls -la'). O seu retorno � um objeto do tipo �Process�, e � atrav�s deste objeto que capturaremos o retorno caso sucesso ou erro.

Nas linhas a seguir chamamos o m�todo inputStreamToString que faz a convers�o de InputStream para String (explicaremos mais � frente):


result.put("input", inputStreamToString(proc.getInputStream()));
  result.put("error", inputStreamToString(proc.getErrorStream()));

O objeto Process possui o getInputStream e getErrorStream, onde o primeiro possui o conte�do de retorno quando sucesso, e o segundo possui o conte�do de erro quando falha.

Se n�o houver falhas, ent�o o valor da chave �error� ficar� vazia, por�m, se houver erro o valor da chave �input� ficar� vazio. Se ocorrer um erro interno de IOException gravamos a causa dele na chave �error� do nosso Map:


 catch (IOException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
     result.put("error", e.getCause().getMessage());       
  }

Com isso garantimos que o usu�rio que estar� usando o Emulador de Terminal saber� o que est� ocorrendo e que seu comando n�o foi executado.

O hist�rico ser� gravado independente se houve ou n�o erro, por isso colocamos ele no bloco finally:


 finally{
    commandHistory.add(command);
  }

O m�todo inputStreamToString() converte um objeto do tipo InputStream para String. Para que isso seja poss�vel � criado um InputStreamReader e posteriormente um BufferedReader. � com o BufferedReader que fazemos a leitura das linhas atrav�s do �readLine()�.

Fterminal

Dada a explicaç�o necess�ria para uso do TerminalEmulator.java podemos começar a construç�o do nosso formul�rio Fterminal, que far� a �ponte� entre o usu�rio e o TerminalEmulator. Ele ser� igual a Figura 1.

Figura 1. Fterminal

Nosso formul�rio tem dois JtextArea, sendo o primeiro servidor como console para digitaç�o de comandos e o segundo para sa�da dos comandos. Chamamos de �jTextAreaTerminal� e �jTextAreaOutput�, respectivamente.

Vejamos nossa classe Fterminal por completo na Listagem 2.


package br.com.lab;
 
import java.awt.Color;
import java.awt.event.KeyEvent;
import java.util.Map;
 
import javax.swing.JOptionPane;
 
 
public class FTerminal extends javax.swing.JFrame {
 
    /**
          *
          */
         private static final long serialVersionUID = 1L;
         /**
     * Creates new form FTerminal
     */
    public FTerminal() {
        initComponents();
    }
 
    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">
    //GEN-BEGIN:initComponents
    private void initComponents() {
 
        jButtonExec = new javax.swing.JButton();
        jScrollPane1 = new javax.swing.JScrollPane();
        jTextAreaTerminal = new javax.swing.JTextArea();
        jScrollPane2 = new javax.swing.JScrollPane();
        jTextAreaOutput = new javax.swing.JTextArea();
        jButtonHistory = new javax.swing.JButton();
 
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
 
        jButtonExec.setText("Executar");
        jButtonExec.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButtonExecActionPerformed(evt);
            }
        });
 
        jTextAreaTerminal.setBackground(new java.awt.Color(216, 208, 201));
        jTextAreaTerminal.setColumns(20);
        jTextAreaTerminal.setRows(5);
        jTextAreaTerminal.addKeyListener(new java.awt.event.KeyAdapter() {
            public void keyPressed(java.awt.event.KeyEvent evt) {
                jTextAreaTerminalKeyPressed(evt);
            }
        });
        jScrollPane1.setViewportView(jTextAreaTerminal);
 
        jTextAreaOutput.setEditable(false);
        jTextAreaOutput.setColumns(20);
        jTextAreaOutput.setRows(5);
        jScrollPane2.setViewportView(jTextAreaOutput);
 
        jButtonHistory.setText("Hist�rico");
        jButtonHistory.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButtonHistoryActionPerformed(evt);
            }
        });
 
        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
        layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
        .addGroup(layout.createSequentialGroup()
        .addContainerGap()
        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane1)
            .addGroup(layout.createSequentialGroup()
                .addComponent(jButtonExec)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(jButtonHistory)
                .addGap(0, 0, Short.MAX_VALUE))
            .addComponent(jScrollPane2, javax.swing.GroupLayout.DEFAULT_SIZE, 
            528, Short.MAX_VALUE))
        .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.
            createSequentialGroup()
                .addContainerGap()
                .addComponent(jScrollPane1, javax.swing.GroupLayout.
                PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.
                PREFERRED_SIZE)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.
                RELATED)
                .addComponent(jScrollPane2, javax.swing.GroupLayout.DEFAULT_SIZE, 134, 
                Short.MAX_VALUE)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.
                Alignment.BASELINE)
                    .addComponent(jButtonHistory)
                    .addComponent(jButtonExec))
                .addGap(14, 14, 14))
        );
 
        pack();
    }// </editor-fold>//GEN-END:initComponents
 
    private void jButtonHistoryActionPerformed(java.awt.event.ActionEvent evt) 
    {//GEN-FIRST:event_jButtonHistoryActionPerformed
        DHistory dhistory = new DHistory(this, true);        
        String command = dhistory.getSelectedCommand();
        if (command != null){
         jTextAreaTerminal.setText(command);
        }
    }//GEN-LAST:event_jButtonHistoryActionPerformed
 
    private void jButtonExecActionPerformed(java.awt.event.ActionEvent evt) 
    {//GEN-FIRST:event_jButtonExecActionPerformed
                   exec();
    }//GEN-LAST:event_jButtonExecActionPerformed
 
    private void jTextAreaTerminalKeyPressed(java.awt.event.KeyEvent evt) 
    {//GEN-FIRST:event_jTextAreaTerminalKeyPressed
        if (evt.getKeyCode() == KeyEvent.VK_F5){
         exec();
        }
    }//GEN-LAST:event_jTextAreaTerminalKeyPressed
 
    private void exec(){
         String command = jTextAreaTerminal.getText().trim();
         if (command == null || command.equals("")){
           JOptionPane.showMessageDialog(this, "O comando n�o pode ser vazio");
         }else{
         Map<String,String> result = TerminalEmulator.exec(command);
         
         if (result.get("error") != null && !result.get("error").equals("")){
                  writeOutput(result.get("error"), true);
         }else if (result.get("input") != null && !result.get("input").equals("")){
                  writeOutput(result.get("input"), false);
         }
         }
    }
    
    private void clearOutput(){
         jTextAreaOutput.setText("");
    }
    
    
    private void paintOutput(boolean error){
     if (error){
          jTextAreaOutput.setForeground(Color.RED);
     }else{
          jTextAreaOutput.setForeground(Color.BLACK);
     }
    }
    
    private void writeOutput(String text, boolean error){
         clearOutput();
         paintOutput(error);
         jTextAreaOutput.setText(text);      
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        /* Set the Nimbus look and feel */
        //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
        /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
         * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
         */
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : 
            javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException ex) {
            java.util.logging.Logger.getLogger(FTerminal.class.getName()).log(
            java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(FTerminal.class.getName()).log(
            java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(FTerminal.class.getName()).log(
            java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(FTerminal.class.getName()).log(
            java.util.logging.Level.SEVERE, null, ex);
        }
        //</editor-fold>
 
        /* Create and display the form */
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new FTerminal().setVisible(true);
            }
        });
    }
    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JButton jButtonExec;
    private javax.swing.JButton jButtonHistory;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JScrollPane jScrollPane2;
    private javax.swing.JTextArea jTextAreaOutput;
    private javax.swing.JTextArea jTextAreaTerminal;
    // End of variables declaration//GEN-END:variables
}

Listagem 2. Fterminal.java

Se voc� estiver usando Netbeans para criaç�o de formul�rios perceber� que alguns m�todos s�o padr�es e n�o perderemos muito tempo neles:

public Fterminal(): Construtor padr�o do formul�rio;
initComponents(): Inicializa os componentes do formul�rio;
main(): M�todo que possibilita a execuç�o do formul�rio como sendo o formul�rio principal do projeto.

Vejamos agora os m�todos importantes a serem explicados:

clearOutput(): Apenas limpa o conte�do que de sa�da do jTextAreaOutput, que pode ser um ERRO retornado ou um conte�do v�lido;
paintOutptu(boolean error): Pinta o jTextAreaOutput de acordo com a condiç�o error, sendo que, ao ocorrer um erro a mensagem ser� pintada de VERMELHO, caso contr�rio PRETA;
writeOutput(String text, boolean error): Ao executar um comando no TerminalEmulator a sa�da deste comando � escrita no jTextAreaOutput atrav�s deste m�todo;
exec(): Captura o texto digitado no jTextAreaTerminal e chama a sua execuç�o para o TerminalEmulator. Caso a chave �error� n�o tenha nenhum conte�do, ent�o ele chama o writeOutput indicando que n�o h� erros e passa o valor contido na chave �input�.
jTextAreaTerminalKeyPressed: Verifica se foi pressionada a tecla F5 e chama o m�todo exec(), possibilitando sua execuç�o r�pida;
jButtonExecActionPerformed: Chama diretamente o m�todo exec() quando o bot�o �Executar� for clicado;
jButtonHistoryActionPerformed: Este m�todo est� ligado ao bot�o �Hist�rico� e � executado no seu click. A sua funç�o � chamar a classe Dhistory (que ser� mostrada mais a frente) e capturar o comando que foi selecionado neste formul�rio. Caso algum comando tenha sido selecionado, ent�o este � setado no jTextAreaTerminal, possibilitando que o usu�rio possa re-execut�-lo.

Dhistory

O objetivo desta classe, que trata-se de um Jdialog, � mostrar o hist�rico de comandos j� executados, possibilitar a limpeza destes ou a sua execuç�o, conforme a Figura 2.

Figura 2. Dhistory

O formul�rio Dhistory possui um Jlist que cont�m a lista de comandos j� executados, al�m de um bot�o Confirmar, que seleciona um comando e o envia para o Fterminal afim de ser executado. O bot�o �Limpar� faz chamada ao clearHistory() do TerminalEmulator afim de limpar o hist�rico de comandos executados.

Vejamos a classe Dhistory.java por completo na Listagem 3.


package br.com.lab;

import javax.swing.DefaultListModel;

public class DHistory extends javax.swing.JDialog {

  /**
      *
      */
     private static final long serialVersionUID = 1L;
     private DefaultListModel lista = new DefaultListModel();
  
  /**
   * Creates new form DHistory
   */
  public DHistory(javax.swing.JFrame parent, boolean modal) {
      super(parent, modal);
      initComponents();
      loadHistory();
      setVisible(true);
  }
  
  private void loadHistory(){
       jListHistory.setModel(lista);
       for(String hi : TerminalEmulator.getCommandHistory()){
        lista.addElement(hi);
       }
  }

  /**
   * This method is called from within the constructor to initialize the form.
   * WARNING: Do NOT modify this code. The content of this method is always
   * regenerated by the Form Editor.
   */
  @SuppressWarnings("unchecked")
  // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
  private void initComponents() {

      jScrollPane1 = new javax.swing.JScrollPane();
      jListHistory = new javax.swing.JList();
      jButtonConfirm = new javax.swing.JButton();
      jButtonClear = new javax.swing.JButton();

      setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);

      jScrollPane1.setViewportView(jListHistory);

      jButtonConfirm.setText("Confirmar");
      jButtonConfirm.addActionListener(new java.awt.event.ActionListener() {
          public void actionPerformed(java.awt.event.ActionEvent evt) {
              jButtonConfirmActionPerformed(evt);
          }
      });

      jButtonClear.setText("Limpar");
      jButtonClear.addActionListener(new java.awt.event.ActionListener() {
          public void actionPerformed(java.awt.event.ActionEvent evt) {
              jButtonClearActionPerformed(evt);
          }
      });

      javax.swing.GroupLayout layout = new javax.swing.
      GroupLayout(getContentPane());
      getContentPane().setLayout(layout);
      layout.setHorizontalGroup(
          layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
          .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, 
          layout.createSequentialGroup()
              .addContainerGap()
              .addComponent(jScrollPane1, javax.swing.GroupLayout.
              DEFAULT_SIZE, 376, Short.MAX_VALUE)
              .addContainerGap())
          .addGroup(layout.createSequentialGroup()
              .addGap(107, 107, 107)
              .addComponent(jButtonConfirm)
              .addGap(18, 18, 18)
              .addComponent(jButtonClear, javax.swing.GroupLayout.
              PREFERRED_SIZE, 79, javax.swing.GroupLayout.PREFERRED_SIZE)
              .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
      );
      layout.setVerticalGroup(
          layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
          .addGroup(layout.createSequentialGroup()
              .addContainerGap()
              .addComponent(jScrollPane1, javax.swing.GroupLayout.
              PREFERRED_SIZE, 230, javax.swing.GroupLayout.PREFERRED_SIZE)
              .addGap(18, 18, 18)
              .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                  .addComponent(jButtonConfirm)
                  .addComponent(jButtonClear))
              .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
      );

      pack();
  }// </editor-fold>//GEN-END:initComponents

  private void jButtonConfirmActionPerformed(java.awt.event.ActionEvent evt)
  {//GEN-FIRST:event_jButtonConfirmActionPerformed
      dispose();
  }//GEN-LAST:event_jButtonConfirmActionPerformed

  private void jButtonClearActionPerformed(java.awt.event.ActionEvent evt) 
  //GEN-FIRST:event_jButtonClearActionPerformed
      TerminalEmulator.clearHistory();
      jListHistory.removeAll();
      dispose();
  }//GEN-LAST:event_jButtonClearActionPerformed

  public String getSelectedCommand(){
     if (jListHistory.getSelectedValue() != null){
           return jListHistory.getSelectedValue().toString();
     }else{
           return null;
     }
  }
  
  /**
   * @param args the command line arguments
   */
  public static void main(String args[]) {
      /* Set the Nimbus look and feel */
      //<editor-fold defaultstate="collapsed" desc=" Look and feel 
      setting code (optional) ">
      /* If Nimbus (introduced in Java SE 6) is not available, stay with 
      the default look and feel.
       * For details see http://download.oracle.com/javase/tutorial/uiswing/
       lookandfeel/plaf.html
       */
      try {
          for (javax.swing.UIManager.LookAndFeelInfo info : 
          javax.swing.UIManager.getInstalledLookAndFeels()) {
              if ("Nimbus".equals(info.getName())) {
                  javax.swing.UIManager.setLookAndFeel(info.getClassName());
                  break;
              }
          }
      } catch (ClassNotFoundException ex) {
          java.util.logging.Logger.getLogger(DHistory.class.getName())
          .log(java.util.logging.Level.SEVERE, null, ex);
      } catch (InstantiationException ex) {
          java.util.logging.Logger.getLogger(DHistory.class.getName())
          .log(java.util.logging.Level.SEVERE, null, ex);
      } catch (IllegalAccessException ex) {
          java.util.logging.Logger.getLogger(DHistory.class.getName())
          .log(java.util.logging.Level.SEVERE, null, ex);
      } catch (javax.swing.UnsupportedLookAndFeelException ex) {
          java.util.logging.Logger.getLogger(DHistory.class.getName())
          .log(java.util.logging.Level.SEVERE, null, ex);
      }
      //</editor-fold>

      /* Create and display the dialog */
      java.awt.EventQueue.invokeLater(new Runnable() {
          public void run() {
              DHistory dialog = new DHistory(new javax.swing.JFrame(), true);
              dialog.addWindowListener(new java.awt.event.WindowAdapter() {
                  @Override
                  public void windowClosing(java.awt.event.WindowEvent e) {
                      System.exit(0);
                  }
              });
              dialog.setVisible(true);
          }
      });
  }
  // Variables declaration - do not modify//GEN-BEGIN:variables
  private javax.swing.JButton jButtonClear;
  private javax.swing.JButton jButtonConfirm;
  private javax.swing.JList jListHistory;
  private javax.swing.JScrollPane jScrollPane1;
  // End of variables declaration//GEN-END:variables
}

Listagem 3. Dhistory.java

Logo no in�cio temos a definiç�o de um DefaultListModel que ser� usado no Jlist, afim de realizar as operaç�es de inserç�o e remoç�o de elementos deste componente. Logo ap�s, no construtor da classe, temos o uso de um m�todo chamado loadHistory() que far� o carregamento de todos os hist�ricos no componente jListHistory e a configuraç�o do DefaultListModel:


private void loadHistory(){
  jListHistory.setModel(lista);
  for(String hi : TerminalEmulator.getCommandHistory()){
  lista.addElement(hi);
 }
}

Perceba que � feita uma iteraç�o nos comandos do TerminalEmulator para adicionar um por um no DefaultListModel.

O bot�o �Confirmar�, que est� ligado ao m�todo jButtonConfirmActionPerformed, s� tem a funç�o de fechar o formul�rio, pois o que nos interessa � apenas selecionar um comando para posteriormente captur�-lo de outros formul�rios. Fazemos isso atrav�s do m�todo getSelectedCommand() que retorna o comando selecionado caso ele exista.

Por fim, temos o bot�o �Limpar� que est� ligado ao m�todo jButtonClearActionPerformed(), que por usa vez faz chamada ao m�todo clearHistory() do TerminalEmulator limpando o hist�rico e os valores do JlistHistory e, finalmente faz o dispose() do formul�rio, afinal n�o h� porque o usu�rio continuar naquele formul�rio se n�o h� mais comandos a serem selecionados.

Lembre-se que ap�s selecionar o comando e clicar em Confirmar o formul�rio � fechado, voltando a execuç�o do programa para o Fterminal que ir�, por sua vez, usar o getSelectedCommand() para inserir o valor selecionado no jTextAreaTerminal.

Vimos neste artigo como criar um emulador de terminal Linux em Java, usando a classe Runtime e diversos outros recursos do Java. � importante salientar que melhorias podem ser realizadas neste projeto, pois trata-se apenas de um prot�tipo para fins did�ticos. Voc� pode ir muito al�m, adicionando o hist�rico de comandos ao banco de dados, hora de execuç�o, quem executou, valor retornado e etc.

Emulador de Terminal Linux com a classe Java Runtime

Veja neste artigo como usar a classe Runtime para criar um emulador de terminal linux.

TerminalEmulator

Fterminal

Dhistory

Aprenda ainda mais

Artigos relacionados