Databind com Jackson e com Google JSON em Java

Com a febre do "two way databind" do Angularjs o beck-end do Java precisa receber um arquivo ou um objeto JSON e transformar em um objeto Java para a camada de negócio. O objetivo do post é converter um JSON em objeto ou um objeto em JSON fazendo uma leitura ou escrita do arquivo ou do objeto JSON. O nome do processo de conversão de JSON para objeto é na verdade Marshal e o inverso Unmarshal.

Vamos criar no Eclipse um novo Projeto em File>>New>>Other>>Dinamyc Web Project com o nome de JaxonTest.

Next>>Next>> Clica em generate web.xml e fnaliza.

Com o botão direito do mouse sobre o projeto clicar em Configure>>Convert to Maven Project.


Vai ser criado o arquivo pom.xml e vamos adicionar as dependencias dentro da tag <dependecies>.

1. <dependencies>
2.   <dependency>
3.    <groupId>com.fasterxml.jackson.core</groupId>
4.    <artifactId>jackson-annotations</artifactId>
5.    <version>2.6.3</version>
6.   </dependency>
7.   <dependency>
8.    <groupId>com.fasterxml.jackson.core</groupId>
9.    <artifactId>jackson-core</artifactId>
10.    <version>2.6.3</version>
11.   </dependency>
12.   <dependency>
13.    <groupId>com.fasterxml.jackson.core</groupId>
14.    <artifactId>jackson-databind</artifactId>
15.    <version>2.6.3</version>
16.   </dependency>
17.   <dependency>
18.    <groupId>org.codehaus.jackson</groupId>
19.    <artifactId>jackson-mapper-asl</artifactId>
20.    <version>1.9.13</version>
21.   </dependency>
22.  </dependencies>

Agora basta clicar em Maven>>Update Project e as dependências serão baixadas automaticamente e poderão ser visualizadas dentro de Java Rersources>>Libraries>>Maven Dependencies.

Vamos criar tres pacotes agora model, read e write.

Vamos criar em model o arquivo User.java com três variáveis, getters and setters e contrutores:

1. package br.marcelo.model;
2. import java.util.List;
3.  
4.  
5. public class User {
6.  
7.  
8.  private String nome;
9.  private int age;
10.  private List<String> messages;
11.  
12.  public User() {
13.   super();
14.   // TODO Auto-generated constructor stub
15.  }
16.  public User(String nome, int age, List<String> messages) {
17.   super();
18.   this.nome = nome;
19.   this.age = age;
20.   this.messages = messages;
21.  }
22.  public String getNome() {
23.   return nome;
24.  }
25.  public void setNome(String nome) {
26.   this.nome = nome;
27.  }
28.  public int getAge() {
29.   return age;
30.  }
31.  public void setAge(int age) {
32.   this.age = age;
33.  }
34.  public List<String> getMessages() {
35.   return messages;
36.  }
37.  public void setMessages(List<String> messages) {
38.   this.messages = messages;
39.  }
40.   
41. }
42. 
    

Vamos criar o primeiro exemplo em write.

1. package br.marcelo.write;
2.  
3. import java.io.File;
4. import java.io.IOException;
5. import java.util.ArrayList;
6. import java.util.List;
7.  
8. import org.codehaus.jackson.JsonGenerationException;
9. import org.codehaus.jackson.map.JsonMappingException;
10. import org.codehaus.jackson.map.ObjectMapper;
11.  
12. import br.marcelo.model.User;
13.  
14. public class Exemplo1 {
15.  public static void main(String[] args) {
16.  
17.   ObjectMapper mapper = new ObjectMapper();
18.   String curDir;
19.   //For testing
20.   User user = new User();
21.  
22.   user.setNome("Marcelo");
23.   user.setAge(30);
24.  
25.   List<String> messages = new ArrayList<>();
26.   messages.add("mensagem1");
27.   messages.add("mensagem2");
28.   user.setMessages(messages);
29.  
30.   try {
31.    //Get current Directory
32.    curDir = System.getProperty("user.dir");
33.    //Convert object to JSON string and save into file directly
34.    mapper.writeValue(new File(curDir+"\\user.json"), user);
35.    System.out.println("Arquivo localizado em: "+curDir+"\\user.json");
36.    
37.    //Convert object to JSON string
38.    String jsonInString = mapper.writeValueAsString(user);
39.    System.out.println(jsonInString);
40.    
41.    //Convert object to JSON string and pretty print
42.    jsonInString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
43.    System.out.println(jsonInString);
44.    
45.    
46.   } catch (JsonGenerationException e) {
47.    e.printStackTrace();
48.   } catch (JsonMappingException e) {
49.    e.printStackTrace();
50.   } catch (IOException e) {
51.    e.printStackTrace();
52.   }
53.  
54.  }
55.  
56.  
57. }

Neste exemplo utilizamos ObjectMapper() para a criação do arquivo, o objeto user é criado e enviado para o diretório determinado. Segue a saida do console em JSON:


{"nome":"Marcelo","age":30,"messages":["mensagem1","mensagem2"]}
{
  "nome" : "Marcelo",
  "age" : 30,
  "messages" : [ "mensagem1", "mensagem2" ]
}



Agora vamos ler o arquivo criado utilizando o mesmo formato no Exemplo2.java no pacote read.

1. package br.marcelo.read;
2.  
3. import java.io.File;
4. import java.io.IOException;
5.  
6. import com.fasterxml.jackson.core.JsonGenerationException;
7. import com.fasterxml.jackson.databind.JsonMappingException;
8. import com.fasterxml.jackson.databind.ObjectMapper;
9.  
10. import br.marcelo.model.User;
11.  
12. public class Exemplo2 {
13.  
14.  public static void main(String[] args) {
15.   Exemplo2 obj = new Exemplo2();
16.   obj.run();
17.  }
18.  
19.  private void run() {
20.   ObjectMapper mapper = new ObjectMapper();
21.  
22.   String curDir;
23.   try {
24.    //Get current Directory
25.    curDir = System.getProperty("user.dir");
26.    // Convert JSON string from file to Object
27.    User user = mapper.readValue(new File(curDir+"\\user.json"), User.class);
28.    System.out.println(user);
29.  
30.    //Pretty print
31.    String prettyStaff1 = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
32.    System.out.println(prettyStaff1);
33.    
34.    
35.   } catch (JsonGenerationException e) {
36.    e.printStackTrace();
37.   } catch (JsonMappingException e) {
38.    e.printStackTrace();
39.   } catch (IOException e) {
40.    e.printStackTrace();
41.   }
42.  }
43.  
44. }

No Exemplo3 vamos receber o objeto em um objeto do tipo Object() que pode ser qualquer tipo de objeto.

1. package br.marcelo.read;
2.  
3. import java.io.File;
4. import java.io.IOException;
5.  
6. import com.fasterxml.jackson.core.JsonGenerationException;
7. import com.fasterxml.jackson.databind.JsonMappingException;
8. import com.fasterxml.jackson.databind.ObjectMapper;
9.  
10.  
11.  
12. public class Exemplo3 {
13.  
14.  public static void main(String[] args) {
15.   Exemplo3 obj = new Exemplo3();
16.   obj.run();
17.  }
18.  
19.  private void run() {
20.   ObjectMapper mapper = new ObjectMapper();
21.  
22.   String curDir;
23.   try {
24.    // Get current Directory
25.    curDir = System.getProperty("user.dir");
26.    // Convert JSON string from file to Object
27.    Object object = mapper.readValue(new File(curDir + "\\user.json"), Object.class);
28.    System.out.println(object);
29.    
30.    //System.out.println(object.getClass().getName());
31.    
32.    // Pretty print
33.    String prettyStaff1 = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(object);
34.    System.out.println(prettyStaff1);
35.  
36.   } catch (JsonGenerationException e) {
37.    e.printStackTrace();
38.   } catch (JsonMappingException e) {
39.    e.printStackTrace();
40.   } catch (IOException e) {
41.    e.printStackTrace();
42.   }
43.  }
44.  
45. }

Para o próximo exemplo vamos adicionar ao arquivo pom.xml uma nova dependência:

1. <dependency>
2.    <groupId>com.googlecode.json-simple</groupId>
3.    <artifactId>json-simple</artifactId>
4.    <version>1.1.1</version>
5.   </dependency>

Vamos atualizar novamente o projeto em Maven>>Update Project e a nova dependência poderá ser visualizada nas Libraries.

No Exemplo4.java o objeto é recebido em um objeto do tipo JSONObject.

1. package br.marcelo.read;
2.  
3. import java.io.FileNotFoundException;
4. import java.io.FileReader;
5. import java.io.IOException;
6. import java.util.Iterator;
7. import java.util.List;
8.  
9. import org.json.simple.JSONObject;
10. import org.json.simple.parser.JSONParser;
11. import org.json.simple.parser.ParseException;
12.  
13. public class Exemplo4 {
14.  
15.  public static void main(String[] args) {
16.   JSONObject jsonObject;
17.   //Cria o parse de tratamento
18.   JSONParser parser = new JSONParser();
19.   //Variaveis que irao armazenar os dados do arquivo JSON
20.   String nome;
21.   Long age;
22.   List<String> messages;
23.   String curDir;
24.  
25.   try {
26.    // Get current Directory
27.    curDir = System.getProperty("user.dir");
28.    //Salva no objeto JSONObject o que o parse tratou do arquivo
29.    jsonObject = (JSONObject) parser.parse(new FileReader(
30.      curDir + "\\user.json"));
31.    
32.    /*//Salva nas variaveis os dados retirados do arquivo
33.    name = (String) jsonObject.get("nome");
34.    age = (Long) jsonObject.get("age");
35.    messages = (List<String>) jsonObject.get("messages");*/
36.    
37.     for (Iterator it = jsonObject.keySet().iterator(); it.hasNext();) {  
38.               Object key = it.next();  
39.               Object item = jsonObject.get(key);  
40.               System.out.println(key+":"+item);
41.     }      
42.  
43.    
44.  
45.   }
46.   //Trata as exceptions que podem ser lançadas no decorrer do processo
47.   catch (FileNotFoundException e) {
48.    e.printStackTrace();
49.   } catch (IOException e) {
50.    e.printStackTrace();
51.   } catch (ParseException e) {
52.    // TODO Auto-generated catch block
53.    e.printStackTrace();
54.   }
55.  }
56.  
57. }

Referencias:

http://www.mkyong.com/java/jackson-2-convert-java-object-to-from-json/

http://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson/

http://stackoverflow.com/questions/18429468/correct-set-of-dependencies-for-using-jackson-mapper

Java é Java!

 Quando eu era estudante não entendia porque o programador batia no peito e sentia orgulhoso ao dizer que programava em Java. O ego do programador Java sempre me transmitia de uma pessoa algumas vezes não muito agradável e que acha que sabe tudo. Comecei a trajetória com PL/SQL, quando era secundarista, e depois com PHP, no inicio da faculdade. O PL/SQL foi substituido pelo PHP nos aplicativos WEB porque o código do PL/SQL exibia as variáveis na opção de exibir código fonte. Trabalhei com API's que imprimiam no browser via comando "http.print('');" em PL/SQL.

Quando comecei a trabalhar com PHP percebia que o desenvolvimento em PHP era muito mais rápido apesar do Java ser um pouco mais seguro e verboso e por isso mais lento de se desenvolver. Você faz uma linha em PHP para escrever três em Java para executar uma mesma operação e isso me parecia lento.  

Quando comecei a trabalhar com Java falei aos programadores mais antigos que não achava que Java fosse tudo aquilo que se falava. Acabei ouvindo frases como "você não sabe o que está falando" e também ouvi uma que nunca que esqueci: "quando você começar a andar pelas empresas e ver o cenário de caos você vai entender o que é o Java". Bom, o cenário de caos apareceu.

Continuo achando que o PHP é mais rápido para pequenos sites, mas tudo depende também do cenário. Hoje, existe uma euforia criada pelo "two way data bind do Angularjs" que parece ser interessante. Porém o PL/SQL se mostrou extremamente fraco para desenvolvimento em equipe. Existem duas grandes questões para essa fraqueza que seriam as ferramentas utilizadas para SVN e GIT que na grande maioria não possuem uma opção de merge que funcione como a do Eclipse (mesmo as Eclipse based) e a segunda seria o problema da Integração Contínua e quem já programou em Java sabe do que estou falando.

Na pratica arquivos são alterados e jogados diretamente em produção e o GIT acaba não sendo atualizado e isso jamais aconteceria com o Java porque o processo de Integração Continua garante que o arquivo alterado seja atualizado primeiro na base de homologação, depois seja testado e atualizado na base produtiva. No PHP a Integração Continua talvez nem faça sentido já que não é necessário criar um arquivo *.WAR. Mas como compilar o código para criar uma nova base em PL/SQL puro? E como fazer com os dados? Não encontrei nenhuma forma eficiente, mesmo que se fizesse utilizando Shellscript. E se a rede for baseada em Windows então?

A escolha da linguagem também depende do cenário, da necessidade ou possibilidade de investimento, se a aplicação vai ficar restrita em uma rede interna ou se vai ficar em rede aberta, se deve rodar no browser ou no desktop, no computador, no tablet, no celular ou em algum coletor de dados. Para tanto o Java é a única linguagem que oferece suporte para qualquer aplicação seja no Windows, no Linux ou no Mac.

Comparado o Java com o PHP, pode ser que com PHP seja mais rápido fazer uma aplicação pequena, mas se aplicação depender de muitas conexões somente o Java poderá gerenciar um Pool de conexões para um grande volume de usuários. E tem ainda a questão das Threads (processamento concorrente) que só existem em Java. Mesmo a comunicação via Serial/USB possui uma biblioteca rxtx específica em Java, a única linguagem que chega mais perto com exceção de C é o Python, porém o Java depois que fecha uma conexão via rxtx em uma porta bloqueia outras requisições na mesma porta ate o encerramento da mesma e o Python permite que vários aplicativos se comuniquem nesta mesma porta utilizada o que pode gerar um "crush" de informações.

O Ruby on Rails quando foi lançado ganhou mercado por já ser Orientado a Objetos e por ser 20 vezes mais rápido que o Java em alguns testes. Foi quando lançaram a segunda versão do compilador e as aplicações começaram a parar porque o compilador havia sido alterado e alguns comandos não possuíam mais suporte. E quando lançaram a terceira versão do compilador aconteceu novamente.

Voltando ao Java, na verdade a grande pergunta que todo o desenvolvedor Java faz a si mesmo e aos companheiros é: "afinal, se você tivesse que iniciar um projeto Java hoje, que tecnologias você usaria?" e essa é a grande questão.

Há um ano atrás eu provavelmente jamais escolheria o Angularjs, porém o tempo tem se mostrado a favor e muitas empresas estão decidindo utilizar o Angularjs no front-end com o Java no back-end. Foi lançado recentemente a versão 2.0 e parece que ambas as versões podem funcionar simultaneamente e o fato do código ser mantido pela Google traz um pouco de tranquilidade. Já no back-end se desenvolveu uma nova forma de trabalhar e ao invés de se programar com um simples MVC está sendo usado Rest antes da camada de modelo. O próprio Spring pode ser desbravado com ou sem o Hibernate e agora existe a opção do Rest junto a tudo isso. Como o Angularjs trabalha com a opção de envio de um único objeto em JSON para o back-end então existe a necessidade de se transformar o JSON em um objeto para a camada de service e essa opção pode ser dada por algumas bibliotecas como JAXB na camada service ou outra opção JAX-RS na camada de modelo.

O fato é que Java é Java. E a pergunta continua: "afinal, se você tivesse que iniciar um projeto Java hoje, que tecnologias você usaria?"

Atualizando Servidor com Horário de Verão

Com a alteração do horário de verão existe a necessidade da atualização do servidor. Para fazer essa alteração é necessário acessar como root.

Para a exibição da hora não é necessário root, apenas para a alteração.  

Exibe data e hora:

$ date

A saída exibirá algo parecido com:

Mon Oct 19 09:58:19 BRST 2015

Altera hora para 10:00 horas:

# date -s "10:00"

Informações de manual do comando:

$ man date

Outra forma:

# date -s 'hh:mm:ss'

Sendo:

hh: a hora de 00 à 23

mm: minutos com 2 dígitos de 00 a 59

ss: segundos com 2 dígitos de 00 a 59

Apenas a data:

# date mmddhhmmyyyy

Sendo:

mm: mês

dd: dia

hh: hora

mm: minuto

yyyy: ano

Outra forma:

Atualizando data

# date -s 'yyyymmdd'

yyyy: o ano com 4 dígitos

mm: o mês com 2 dígitos

dd: o dia com 2 dígitos

Atualizando hora

               

Depois de digitado o comando com os respectivos valores, digite isso para salvar as alterações (algumas distros não precisam desse comando):

# clock -w

Eu considero mais fácil ainda fazendo a conexão com um servidor de hora. No caso o NTP.

Caso não possua o ntpdate instalado você pode instalar a partir do source:http://www.ntp.org/downloads.html, ou se possui o aptitude:

# aptitude install ntpdate

Pode se encontrar uma lista de servidores ntp’s no link:http://support.ntp.org/bin/view/Servers/NTPPoolServers

Com o comando abaixo será feita uma ponte com o servidor (no caso pool.ntp.or) e a data e a hora será baixada para a máquina local onde será imediatamente atualizada:

# ntpdate pool.ntp.org

ou

# ntpdate -u ntp.usp.br

Também pode se utilizar o ip do observatório nacional:

# ntpdate -u 200.20.186.75

No meu caso em uma das máquinas o comando ntpdate constava como “depracated” (desatualizado/ não mais utilizado)

Segue o comando com a mensagem:

/home/usuario # ntpdate -u ntp.usp.br

       !!!!!!!!!!!!!!  WARNING !!!!!!!!!!!!!!!!!!

The ntpdate program is deprecated and should not be used any more.  To

quote the upstream ntp developers:

  "The functionality ntpdate offered is now provided by the ntpd daemon

  itself.  If you call ntpd with the command line option -q it will

  retrieve the current time and set it accordingly."

Please check the Network Time Protocol (NTP) daemon man page and

  http://support.ntp.org/bin/view/Dev/DeprecatingNtpdate

for further information.

You can replace the ntpdate call with "rcntp ntptimeset" to achieve an

inital poll of the servers specified in /etc/ntp.conf.

The program /usr/sbin/sntp offers comparable functionality to ntpdate.

Specifically

  sntp -P no -r pool.ntp.org

is equivalent to

  ntpdate pool.ntp.org

For further details please refer to the man page of sntp.

sntp: not enough valid responses received in time

You have new mail in /var/mail/root

Neste caso foi utilizado o commando referido na mensagem:

#  sntp -P no -r pool.ntp.org

É possível  também colocar o script na cron para ser checado de hora em hora.

# crontab –e

ou

# vi /etc/crontab

Colocar o código:

00 * * * * ntpdate -u pool.ntp.org

Ou se preferir:

*/59 * * * * ntpdate -u pool.ntp.org

Também é possível utilizando o NTP de forma automatizada para entrar e sair do horário de verão na data correta.

Para configurar o cincronismo no arquivo /etc/ntp.conf na linha server:

#vi /etc/ntp.conf

server pool.ntp.org


Para iniciar o serviço:

# service ntpd start

Ou:

# /etc/rc.d/init.d/ntpd start

Ou::

# /etc/init.d/ntp start


Para parar

# /etc/init.d/ntp stop


Para verificar os logs no /var/log/messages:

# tail /var/log/messages

Ou:

# grep ntpd /var/log/messages

Referencia:

https://timalves.wordpress.com/2011/10/11/ntp-resolvendo-problemas-com-horario-de-verao/

Mais da Classe Robot - Usando o Cursor do Mouse

Hoje selecionei um código ainda mais simples para testar a classe Robot. O código abaixo faz a impressão da palavra HELLO no Notepad com um delay de 500 milissegundos entre as letras.


import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.io.IOException;

public class Robot05{
 

  public static void main(String[] args)
                 throws AWTException,IOException{

     int keyInput[] = {
            KeyEvent.VK_H,
            KeyEvent.VK_E,
            KeyEvent.VK_L,
            KeyEvent.VK_L,
            KeyEvent.VK_O
        };

    Runtime.getRuntime().exec("notepad");

    Robot robot = new Robot();

    robot.keyPress(KeyEvent.VK_SHIFT);
    for (int cnt2 = 0;cnt2 < keyInput.length; cnt2++){
      if(cnt2 > 0){
             robot.keyRelease(KeyEvent.VK_SHIFT);
      }
      robot.keyPress(keyInput[cnt2]);
      robot.delay(500);
    }
  }
}



Uma ação bacana da classe é mover o cursor do mouse. Antes um código de programa para capturar e exibir a posição do cursor do mouse.




import java.awt.MouseInfo;


    public class Mouse {
        public static void main(String[] args) {
            while ( true ) {
                System.out.println( MouseInfo.getPointerInfo().getLocation() );
            }
        }
    }



Agora podemos posicionar o mouse em uma localização e capturar os pontos X e Y da localização definida. No programa abaixo definimos as posições que escolhemos usando o código anterior.




import java.awt.AWTException;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Robot;
import java.awt.event.InputEvent;


public class RobotExe {

public static void main(String[] args) {
     
 
        try {
            Robot robot = new Robot();        
         
            robot.delay(5000); // Tempo para o programa abrir        
            Point p = new Point();

            p = MouseInfo.getPointerInfo().getLocation();
            System.out.println("x = " + p.x);
            System.out.println("y = " + p.y);
         
            int x = 291;
            int y = 149;
         
            // Move mouse cursor to x, y
            robot.mouseMove(x, y);

            robot.mousePress(InputEvent.BUTTON1_MASK);
            robot.mouseRelease(InputEvent.BUTTON1_MASK);
         

            robot.mouseWheel(-100);
        } catch (AWTException e) {
            e.printStackTrace();
        }
    }
}


O próximo passo seria armazenar as posições de um intervalo de tempo em um arquivo e depois mandar executar as posições do arquivo criando um buffer de memória de movimentação do cursor. Isso seria suficiente para criar um executável no Windows que pode ser ativado em um determinado horário. Esse foi o artifício usado na história contada do post anterior.

Classe Robot Java

Em 2008 descobri esta classe em Java. A classe ficou bem famosa depois de um advento interessante. Um funcionário de uma grande corporação utilizava esta ferramenta para bater o cartão que era feito computador do usuário. A ferramenta era programada em um determinado horário e assim ele poderia sair antes e deixar o computador ligado. A ferramenta funcionava de segunda a sexta. Porém, em um dia de feriado ele esqueceu de desativar. Os superiores o chamaram para saber como ele havia entrado na empresa em um dia de feriado. Ele contou a verdade e acabou sendo demitido por justa causa.

Alguns exemplos da classe para automatização de tarefas.



Eventos de Teclado:

void keyPress(int keycode) – utilizado para simular o pressionamento de uma tecla;
void keyRelease(int keycode) – remove o status de pressionada de uma tecla utilizada pelo método keyRelease;

Eventos de Mouse:

void mouseMove(int x, int y) – move o mouse para o posição x,y;
void mousePress(int buttons) – pressiona um dos botões do mouse;
void mouseRelease(int buttons) – remove a pressão efetuada pelo método mouseRelease(int buttons);
void mouseWheel(int wheelAmt) – Indica o número de vezes que o scroll será utilizado (aceita valores negativos).

Eventos de Vídeo:

BufferedImage createScreenCapture(Rectangle screenRect) – Captura a imagem existente na tela (na verdade no dispositivo padrão de saída);
Color getPixelColor(int x, int y) – captura a cor do pixel na posição x,y;

Métodos Acessórios:

void delay(int ms) – deixa o a instância de Robot parada (sleeping) por int milisegundos;
void setAutoDelay(int ms) – informa o tempo que a instância da classe Robot deve esperar depois de gerar um evento;
int getAutoDelay() – obtém o valor do autodeley da instância de Robot;
void waitForIdle() – Aguarda até que todos os eventos que estão na fila sejam processados;
void setAutoWaitForIdle(boolean isOn) – define se a instância sempre deve aguardar se todos os eventos da fila sejam processados;
boolean isAutoWaitForIdle() – verifica o estado do autoWaitForIdle;
String toString() – esse método dispensa comentários.






No exemplo abaixo deverá abrir uma calculadora com uma operação e um bloco de notas em seguida.

import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.io.IOException;

public class Robo {
private Robot robot;

public Robo() throws AWTException {
robot = new Robot();
}

/**
* Executa um comando no SO..
*/
public void execute(String comando) throws IOException {
Runtime.getRuntime().exec(comando);
robot.delay(5000); // Tempo para o programa abrir
}

/**
* Copia os dados para a área de transferência.
*/
public void copiar() {
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(KeyEvent.VK_C);
robot.keyRelease(KeyEvent.VK_C);
robot.keyRelease(KeyEvent.VK_CONTROL);
robot.delay(2000);
}

/**
* Cola os dados que estão na área de transferência.
*/
public void colar() {
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_CONTROL);
robot.delay(2000);
}

/**
* Executa a digitação de uma sequência de caracteres.
*/
public void executeTeclas(int... keys) {
if (keys != null) {
for (int key : keys) {
robot.keyPress(key);
robot.keyRelease(key);
}
}
robot.delay(2000); // tempo para o usuário ver o que foi digitado
}

public static void main(String[] args) throws AWTException, IOException {
Robo robo = new Robo();

// Número 25 seguido do sinal +
int[] primeira = { KeyEvent.VK_2, KeyEvent.VK_5, KeyEvent.VK_ADD };
// Número 12 seguido do sinal =
int[] segunda = { KeyEvent.VK_1, KeyEvent.VK_2, KeyEvent.VK_EQUALS };
robo.execute("calc");
robo.executeTeclas(primeira);
robo.executeTeclas(segunda);
robo.copiar();
robo.execute("notepad");
robo.colar();
}
}