Trigger ou Gatilho, é um procedimento interno do banco dados MySQL e Oracle, que possibilita criar blocos de rotinas, que são disparadas/executadas quando houver alguma tentativa de modificação em uma tabela. Normalmente utilizada para manter a integridade da regra de negócio que não pode ser quebra.
A utilização de Trigger possui uma variedade de vantagens, algumas estão listadas abaixo.
- Regra de negócio concentrada no banco de dados. - Processamento rápido. - Criar blocos de rotinas que podem ser disparados antes ou depois de uma modificação.
A Trigger está presente desde a versão 5.0.2 do MySQL. Para disparar uma Trigger, basta executar alguma operação de Insert, Update ou Delete, porém as modificações podem ser realizadas em outra tabela.
Imagine que em um sistema de mercado possua duas tabelas, que são produto e pedidos, porém a tabela produto contém um campo com a quantidade mínima de estoque antes de gerar o pedido, então podemos utilizar a Trigger para fazer esta verificação, se após alguma operação na tabela produto o estoque for menor que a quantidade mínima, a Trigger realiza o cadastro de pedido na tabela pedido, informando o valor para atingir a quantidade máxima, código do produto e data de processamento. Tudo isto sem que o usuário ou vendedor perceba.
Tabelas no MySQL relacionadas
Para o exemplo deste artigo, será utilizado a estrutura de tabelas e valores a seguir.
A rega de negócio será a seguinte, quando for cadastrado um aluno em algum curso, será disparado uma Trigger que faz o cadastro na tabela matricula, informando o código do aluno e código do curso.
A Sintaxe para criação de uma Trigger é exibida abaixo.
CREATE TRIGGER Nome_da_trigger AFTERINSERTON Tabela_que_vai_diparar FOR EACH ROW BEGIN ...Código... END;
CREATETRIGGER: Cria o objeto Trigger. AFTER: Depois de uma ação. INSERT: Inserir. ON: Tabela que fará o disparo. FOREACHROW: Para cada linha. BEGIN: Início END: Fim.
Veja abaixo a tabela dos valores de execução.
Opção
Ação
AFTER
Depois de executar uma ação
BEFORE
Antes de executar uma ação.
Para o nosso caso, será utilizado o evento AFTER, pois, após o cadastro do aluno, a Trigger faz o cadastro automático na tabela matricula.
Podemos fazer as operações usando as ações, Insert, Update e Delete.
Opção
Ação
DELETE
Quando for deletar algo na tabela.
UPDATE
Quando for alterar algo na tabela.
INSERT
Quando for inserir algo na tabela.
Então, criamos a nossa Trigger conforme mostra o código a seguir.
Para que a Trigger fosse criada, foi necessário trocar o delimitador do MySQL para $$, pois como a Trigger utiliza o ;, o MySQL poderá entender como término da instrução e parar o processamento, gerando assim erros na execução.
No Insert, você deve ter notado o NEW.cod e NEW.curso, entenda sua funcionalidade e outro valor é que o OLD.
NEW: Permite retorna o novo valor que foi inserido, neste caso, retorna o código do usuário e curso que foi cadastrado. OLD: Retorna o valor anterior do cadastro, ou seja, sem a alteração atual.
Com a Trigger criada, cadastramos um aluno, o resultado é apresentado na imagem a seguir, note que, a tabela matricula, possui o código do usuário e código curso, isto foi disparado através do Trigger.
Trigger no MySQL
Para exibir as Trigger criadas no banco de dados, utilizamos o código SHOW TRIGGERS.
Código 03:
SHOWTRIGGERS;
Consulta de Trigger no MySQL
Para deletar uma Trigger, utilize o DROPTRIGGERnome_da_trigger.
Com as Trigger é possível realizar operações mais detalhadas, como utilizar variáveis para armazenar valores de uma consulta, com este valor, você utilizar o IF para verificar se o valor é válido, caso contrário aborta a operação e não executa o Insert.
O objetivo desse artigo é inserir o leitor no mundo do desenvolvimento de aplicações em J2ME MIDP. Primeiramente são apresentados alguns conceitos básicos dessa plataforma (secção 1). Em seguida o leitor irá aprender a obter e instalar as ferramentas de desenvolvimento (secção 2). Será apresentado o J2ME Wireless Toolkit (secção 3) com a qual o leitor irá aprender a criar, compilar e testar projetos de aplicativos e entender como são organizados os arquivos de cada projeto. Será mostrado ainda, de forma sucinta, o ciclo de vida de uma MIDlet e como é estruturado o seu código (secção 4). Por fim, serão tecidas as conclusões (secção 5) e apresentadas algumas referências.
Esse artigo destina-se às pessoas que já possuem algum conhecimento em Java e pretendem iniciar seus estudos em J2ME.
1. J2ME (Java 2 Micro Edition)
O J2ME é uma plataforma composta por uma coleção de tecnologias e especificações designadas a dispositivos móveis. O J2ME pode ser visto como uma simplificação do J2SE (Standard Edition) com algumas modificações para possibilitar que Java rode em dispositivos com capacidade limitada, como é o caso dos celulares, pagers, e outros pequenos dispositivos.
Arquitetura do J2ME
A arquitetura do J2ME é composta por três partes: Configurators, Profiles e pacotes extras. Em um nível mais baixo, ela é dividida em dois Configurators. A cada Configurator estão associados Profiles e ainda podem ser acrescentados pacotes extras para prover funcionalidades mais específicas.
Os Configurators são compostos por uma VM (Máquina Virtual) e algumas classes que fornecem as funcionalidades mais básicas dos dispositivos. Os dois tipos de Configurators existentes até agora são:
·Connected Limited Device Configuration (CLDC): para dispositivos bem simples, com memória maior do que 160 KB e processador mínimo de 16MHz, tais como celulares e palms.
·Connected Device Configuration (CDC): para dispositivos com memória superior a 2 MB, tais como PDAs e algumas televisões de terceira geração.
A Figura 1 mostra a arquitetura do J2ME e a divisão entre os dois Configurators.
Os Profiles podem ser vistos como uma especialização de um Configurator. São um conjunto de APIs que definem funções de mais alto nível para uma determinada família de dispositivos.
O Profile que vamos usar nesse tutorial é o MIDP (Mobile Information Device Profile), que tem como base o CLDC. Ele fornece funcionalidades para o desenvolvimento de aplicativos para uma grande variedade de celulares e é atualmente a tecnologia mais usada para desenvolvimento de aplicativos para esses dispositivos. Os aplicativos desenvolvidos com base no MIDP, como os que serão apresentados nesse artigo, são chamados de MIDlets.
Os pacotes opcionais são usados quando se necessita de funcionalidades extras, como de tecnologias como Bluetooth, banco de dados e envio de mensagens.
Figura 1 - Arquitetura do J2ME.
2. Ferramentas para o desenvolvimento com J2ME MIDP
Antes de iniciar o desenvolvimento é necessário dispor de três ferramentas:
·Um editor de texto, para editar o código. Algumas alternativas são o Bloco de Notas, o VIM ou o jEdit (www.jedit.org);
·Java 2 Standard Edition (J2SE) SDK, versão 1.4.2 ou superior. Disponível em http://java.sun.com/j2se/. Basta fazer o download de acordo com o sistema operacional e executar o arquivo de instalação;
·Um ambiente de desenvolvimento com suporte a J2ME MIDP. Nesse artigo vamos usar o J2ME Wireless Toolkit, disponível para Windows e Linux no endereço http://java.sun.com/products/j2mewtoolkit/.
Existem muitos ambientes que suportam MIDP, como o JBuilder e o Code Warrior Wireless Studio. Neste artigo vamos usar o J2ME Wireless Toolkit, da Sun Microsystems, que é um conjunto de ferramentas para o desenvolvimento de aplicações J2ME baseadas em CLDC e MIDP. O J2ME Wireless Toolkit inclui ambiente de compilação, depuração, testes, otimização de desempenho, documentação e exemplos, automatizando uma série de tarefas comuns do processo de desenvolvimento.
3. Como usar o J2ME Wireless Toolkit
Feita a instalação, observe que os arquivos do J2ME Wireless Toolkit vão para um diretório chamado WTK2 (c:\WTK2, no Windows), a menos que seja especificado um nome diferente. Nesse diretório é relevante observar:
1.O arquivo index.html, que contém links para a documentação do Toolkit e para a API do MIDP. Muito útil durante o desenvolvimento e estudo;
2.O diretório apps, onde são armazenados os projetos;
3.O diretório bin, onde estão os executáveis do Toolkit, dentre outros arquivos.
Durante a instalação também são criados atalhos para algumas partes do Toolkit. Execute o atalho para o KToolbar. Deve ser mostrada uma janela como ilustra a Figura 2.
Figura 2 - Janela inicial do J2ME Wireless Toolkit.
Clique no botão Open Project.... Será mostrada uma lista de todos os aplicativos disponíveis. Escolha um deles e clique no botão Open Project.
Uma vez que a aplicação foi aberta, pressione o botão Run. O aplicativo será executado em um emulador, no qual você pode testar o aplicativo.
O J2ME Wireless Toolkit trabalha com projetos cujo produto final é gerar MIDlets. Para criar um projeto, clique no botão New Project.... Será solicitado que o usuário entre com o nome do projeto e o nome da classe principal da MIDlet. Para um primeiro exemplo, coloque o nome do projeto de PrimeiroProjeto e o nome da classe de PrimeiraMIDlet, como mostrado na Figura 3.
Figura 3 - Criação de um novo projeto.
Uma vez preenchidos os nomes do projeto e da classe, o Toolkit mostra uma tela onde é possível configurar algumas propriedades do projeto. Apenas aceite as configurações apresentadas. Esse assunto não será tratado neste artigo.
O Toolkit armazena cada projeto no diretório apps, em um subdiretório com o mesmo nome do projeto. Para o projeto criado anteriormente, o Toolkit criou, no meu computador, o subdiretório c:\WTK2\apps\PrimeiroProjeto, que tem a estrutura padrão mostrada na figura 4.
Figura 4 - Estrutura do diretório de um projeto.
O diretório bin (binaries) contém um arquivo JAR gerado a partir das MIDlets compiladas e um arquivo JAD, que contém uma descrição do MIDlet. O diretório lib (libraries) deve armazenar qualquer arquivo JAR adicional ao projeto. O diretório res (resources) deve armazenar os recursos do projeto, tais como imagens e arquivos texto. Finalmente, o diretório src (sources) é onde os arquivos de código devem ser armazenados.
Quando o projeto é compilado, o Toolkit cria alguns outros diretórios para uso interno.
O próximo passo é escrever o código fonte da MIDlet. Use o seu editor de texto para escrever o código mostrado na Listagem 1. Por hora não vamos nos preocupar com o entendimento do código. Esta descrição será feita mais adiante.
Command exitCommand = new Command("Exit", Command.EXIT, 0);
meuForm.addCommand(exitCommand);
meuForm.setCommandListener(this);
}
public void startApp() {
Display.getDisplay(this).setCurrent(meuForm);
}
public void pauseApp() {}
public void destroyApp(boolean unconditional) {}
public void commandAction(Command cmd, Displayable dis) {
notifyDestroyed();
}
}
Salve o arquivo com o nome de PrimeiraMIDlet.java no diretório src do projeto (no meu computador fica em c:\WTK2\apps\PrimeiroProjeto\src\PrimeiraMIDlet.java).
Pressione o botão Build no KToolbar e espere compilar. Corrija os erros, caso algum ocorra, até compilar o projeto. Em seguida, pressione o botão Run para testá-lo. Você deverá ver um emulador de telefone celular semelhante ao mostrado na Figura 5. Selecione a opção Launch no emulador para executar a MIDlet. O resultado deve ser o apresentado na Figura 6.
Um projeto comporta quantas MIDlets se queira. Para adicionar uma nova MIDlet ao projeto, pressione o botão Settings... no KToolbar. Vai aparecer uma janela onde você deverá ir à guia MIDlets. Edite os campos usando os botões Add e Edit como mostrado na Figura 7.
Figura 5 - O emulador mostra a lista de MIDlets carregadas. No caso, só uma.
Figura 6 - PrimeiraMIDlet rodando no emulador.
Figura 7 - Adicionando MIDlets ao projeto
Agora será necessário escrever o código fonte da SegundaMIDlet, o que significa gerar o arquivo SegundaMIDlet.java e salvá-lo no diretório src do projeto. Para efeito de teste, você pode apenas copiar o código mostrado anteriormente, substituir todas as ocorrências de “PrimeiraMIDlet” por “SegundaMIDlet” e salvar o arquivo como c:\WTK2\apps\PrimeiroProjeto\src\SegundaMIDlet.java.
Compile o projeto e em seguida execute-o para ver o resultado no emulador.
Na janela da Figura 7 pode-se ainda configurar o ícone de cada MIDlet. O campo Icon deve ser preenchido com o caminho até o ícone da respectiva MIDlet. O KToolbar assume que os caminhos são dados relativos a partir do diretório res do projeto. Assim, para o exemplo da Figura 7, nomeie dois arquivos de imagem para icon1.png e icon2.png e salve-os no diretório c:\WTK2\apps\PrimeiroProjeto\res\icons.
Compile o projeto e em seguida execute-o para ver o resultado no emulador. A tela do emulador deve ser parecida com a mostrada na Figura 8, dependendo das imagens dos ícones.
Figura 8 - Duas MIDlets no mesmo projeto, cada qual com um ícone.
4. Entendendo as MIDlets
Agora que já tivemos alguma diversão, vamos entender melhor o que é e como funciona uma MIDlet.
Uma MIDlet é um aplicativo MIDP. Assim como uma Applet é gerenciada por um brownser, uma MIDlet é gerenciada por um software chamado AMS (Application Management Software), presente em cada dispositivo.
Mais tecnicamente, a classe principal de uma MIDlet deve estender a classejavax.microedition.midlet.MIDlet, como pode ser visto na linha 4 do código apresentado na Listagem 1. Nessa classe principal devem ser definidos três métodos: startApp(), pauseApp() e destroyApp(); os quais definem os três estados possíveis do ciclo de vida de uma MIDlet. Estes estados são:
·Pausado – É o estado inicial da MIDlet, assumido assim que ela começa a ser construída pelo AMS. O AMS também pode levar a MIDlet para este estado quando ela estiver no estado Ativo, como, por exemplo, para atender o telefone ou receber SMS. Nesse caso, o AMS invoca o método pauseApp();
·Ativo – O AMS pode invocar o método startApp() para mudar o estado da MIDlet de Pausado para Ativo. Isso acontece, por exemplo, enquanto o AMS invoca o construtor da MIDlet na inicialização do aplicativo.
·Destruído – A execução termina e os recursos são liberados (é chamado o garbage collector). A MIDlet pode ser destruída a partir de qualquer estado.
A Figura 9 ilustra o ciclo de vida de uma MIDlet.
Figura 9 - Ciclo de vida de uma MIDlet.
Tendo em vista o ciclo de vida mostrado na Figura 9, o esqueleto do código de uma MIDlet é semelhante ao código da Listagem 2, abaixo.
Quando uma MIDlet estiver para ser colocada no estado de Ativa, o MAS chamará startApp(). Isso pode acontecer muitas vezes durante o ciclo de vida do aplicativo. Portanto, é importante pensar bem sobre o que será executado quando o método startApp() for chamado. Muitas vezes, esse método não necessita fazer mais do que tornar visível um objeto da classe Displayable[1] (Listagem 1, linha 17). Código que precisa ser iniciado e persistir por toda a vida da MIDlet deve ser colocado no construtor, que será executado uma única vez.
Com relação ao código da Listagem 1, observa-se a mesma estrutura apresentada na Listagem 2. Percebe-se, porém, algumas diferenças:
·Na linha 1, são importadas as classes do pacote javax.microedition.lcdui. Este pacote define classes para a implementação das GUIs (Graphical User Interface) das MIDlets. As classes Canvas, Display, Form e Command, por exemplo, pertencem a esse pacote.
·Na linha 4, a classe principal do MIDlet implementa CommandListener, que é uma interface para tratar de comandos de alto nível. O método commandAction dessa interface é definido na linha 24.
·Na linha 8 é inicializada uma instância da classe Form. Essa classe define métodos para gerenciar a GUI e a interação com o usuário. Por exemplo, na linha 9 é adicionada à GUI a frase “Minha PimeiraMIDlet funciona!”, a ser mostrada na tela do aparelho quando o aplicativo for executado. Na linha 12 é adicionado o comando para iteração com o usuário criado na linha 11.
·Na linha 13 é definido o Listener para os eventos gerados pelo usuário. No caso, o Listener é a própria classe, uma vez que ela implementa CommandListener.
·Na linha 17, o método setCurrent() aplicado ao objeto Dysplay, determina o objeto da classe Displayable que será visível na tela do aparelho. Nesse caso, é passado um objeto da classe Form, que é derivada da classe Screen que, por sua vez, é derivada de Displayable.
Neste artigo foram apresentadas informações básicas para a iniciação ao desenvolvimento de aplicativos na plataforma J2ME. Em um primeiro momento, foram apresentados os conceitos dessa plataforma e o contexto em que se encontram os aplicativos para celulares. As ferramentas para o desenvolvimento foram apresentadas em seguida com enfoque para o J2ME Wireless Toolkit, para o qual foram resumidas as suas funcionalidades básicas, tais como criar, compilar e testar projetos. Foi ainda apresentado o ciclo de vida de uma MIDlet e explicado os pontos-chave do código de um aplicativo simples.
Agora você aprendeu a base do desenvolvimento de aplicações em MIDP e possui as ferramentas necessárias para o desenvolvimento de MIDlets. Mas para produzir aplicativos mais funcionais você precisa se aprofundar em alguns assuntos como, por exemplo, desenvolvimento de jogos, BlueTooth e serviços de Internet. Algumas referências são apresentadas nos links abaixo.
