Sempre utilizei o Tomcat. Lendo por ai vi algumas vantagens que o Jetty possui. Gostei do fato de você poder alterar sua aplicação e não precisar dar um restart no server para ele atualizar o war e assim utilizar o que foi atualizado. Jetty faz isso observando as mudanças e eu posso escolher o tempo de intervalo entre essas observações, mas não é esse o ponto aqui, é apenas um diferencial que acho interessante destacar. Vamos lá então!
Pré-requisitos…
JDK – Que é composto pelo JRE, que por sua vez é composto pela JVM, isso será necessário já que estamos lidando com um Servidor Web para Java.
Jetty(Binário) – Para esse exemplo estou usando a versão 7.5.x.
Jetty WTP Adaptor – Um plugin para Eclipse que vai melhorar a interação com o Jetty.
Eclipse IDE – Para esse exemplo estou usando o Eclipse Indigo.
Objetivo
Minha intenção com esse post é descrever os passos que fiz para usar o Jetty em uma aplicação e também descrever a solução que usei para a não priorização da welcome-file-list no web.xml pelo Jetty.
Processo de Instalação
Baixe e descompacte o binário do Jetty em um local “decente”. Eu criei uma pasta no C: com o nome de “jetty”, em minúsculo mesmo, e descompactei ali dentro.
No Eclipse, instale o plugin WTP Adaptor utilizando o endereço “http://download.eclipse.org/jetty/updates/jetty-wtp”.
Crie um novo Server Jetty e referencie aquele local onde você descompactou o binário do Jetty.
De um start no Server e vá até o navegador e digite http://localhost:8080, se aparecer a página do Jetty é sinal que o negócio bufow.
Welcome File List não é prioridade
Bom, falar sobre isso é um pouco complicado pois não tenho muito conhecimento. O pouco que entendi é que o Jetty faz uma chamada a um servlet default para impedir que na ausência de um arquivo listado na welcome-list-file retorne um erro 404. Sendo assim ele usa como primeira chamada o “/” efetuando uma requisição, o servlet por sua vez deve fazer um redirect para o que seria a página inicial default, no meu caso o index.jsp.
Procurei e não encontrei onde eu poderia alterar para que o Jetty não fizesse mais isso, mas não encontrei. O que achei foram classes criadas especialmente para iniciar o Jetty setando a página inicial entre outras coisas, mas mais uma vez não é isso que eu quero. Quero continuar na mesma linha do Tomcat.
A solução depois de mais de 18h de pesquisa e tentativas foi aderir a idéia. Acontece que estou usando Struts 2 e sendo assim tenho que criar uma Action que me redireciona para a primeira página. O mais interessante disso é que se depois eu preferir o Jetty posso colocar nessa Action o getInstance para a Factory de EntityManager, mas isso já é assunto para outro post.
Action criada:
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;
public class WelcomeAction {
@Action(value = "", results = {
@Result(name = "welcome", location = "/index.jsp")
}
)
public String execute() {
return "welcome";
}
}
Em uma de minhas aulas de Desenvolvimento de Aplicações Distribuídas recebi a tarefa de criar um CHAT do tipo “Command Line” utilizando Multicast e UDP. Como saiu uma coisa legal então resolvi colocar o código a disposição, que claro pode ser melhorado. Foi utilizado Thread e apenas um arquivo foi criado. Para que exista comunicação, execute o arquivo em cada computador que se deseja efetuar a comunicação. A tarefa foi em grupo e os outros integrantes são citados no arquivo. A classe principal eu resolvi fazer uma referencia ao tipo de coleção utilizada para mensagens pendentes e ao próprio exercício, que ficou algo como My LinkedList Chat Multicast.
package br.com.chat;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
/**
* Classe responsavel por cuidar da interacao do usuario. A classe obtem o nome
* do usuario, mostra as mensagens pendentes recebedidas por uma thread e entao
* pede se o usuario deseja digitar algo para enviar. A classe tambem instancia
* a thread de controle do receive.
*
* @authors Vinicius Knob, Edipo Federle and Marcela Pedrini
*
*/
public class MyLinkedListChatMulticast {
/*
* Local de mensagens pendentes, ainda nao lidas. Todas as mensagens
* recebidas sao guardadas nesse local que eh um array ordenado para depois
* serem lidas. Esse array eh static pois precisa ser compartilhado com uma
* thread.
*/
private static LinkedList<String> mensagensPendentes = new LinkedList<String>();
public static void main(String[] args) {
int porta = 9999;
InetAddress enderecoMulticast;
MulticastSocket socket;
String nomeUsuario;
byte[] dados = new byte[140];
DatagramPacket datagrama;
try {
/*
* Criando o chat
*/
enderecoMulticast = InetAddress.getByName("233.99.77.22");
socket = new MulticastSocket(porta);
socket.joinGroup(enderecoMulticast);
/*
* Obtendo o nome do usuario do chat
*/
nomeUsuario = lerString("Digite seu nome: ");
/*
* Sendo gentil com o usuario
*/
System.out.println("\n***** Ola " + nomeUsuario
+ ", voce esta online! *****\n");
/*
* Enviando apresentacao a todos do chat
*/
dados = criarStringConsole(nomeUsuario, "Estou Online!");
datagrama = new DatagramPacket(dados, dados.length,
enderecoMulticast, porta);
socket.send(datagrama);
/*
* Isso eh um bloco de limpesa do array de bytes.
*/
for (int i = 0; i < dados.length; i++) {
dados[i] = 0;
}
/*
* Instanciando a thread para cuidar do recebimento de mensagens
*/
new GestorReceive(socket, datagrama, nomeUsuario).start();
/*
* Loop que ira mostrar as mensagens pendentes e oferecer ao usuario
* para digitar algo. O boolean controla a vida do laco.
*/
boolean viver = true;
while (viver) {
/*
* Usuario tem a chance de digitar algo para enviar
*/
String mensagem = lerString(">> "); // bloqueante
/*
* Quando o usuario nao deseja digitar nada, entao ele tera que
* digitar um codigo de escape "w!", se nao for usado esse
* codigo, eh por que o usuario digitou algo que deva ser
* enviado a todos.
*/
if (!mensagem.equals("w!")) {
/*
* Se a mensagem for igual a "exit", significa que o usuario
* quer sair, entao a mensagem eh alterada para que seja
* enviado aos outros usuario algo mais decente = [USUARIO
* OFFLINE].
*/
if (mensagem.equals("exit")) {
mensagem = "[USUARIO OFFLINE]";
viver = false;
}
/*
* O que sera mostrado no console do usuario sera a hora
* atual, o nome do usuario que enviou a mensagem e a
* mensagem dele
*/
dados = criarStringConsole(nomeUsuario, mensagem);
datagrama = new DatagramPacket(dados, dados.length,
enderecoMulticast, porta);
socket.send(datagrama);
/*
* Isso eh um bloco de limpesa do array de bytes.
*/
for (int i = 0; i < dados.length; i++) {
dados[i] = 0;
}
}
/*
* Verifica a existencia de mensagens pendentes e as mostra
*/
verificarMensagensPendentes(nomeUsuario);
}
} catch (Exception exc) {
throw new RuntimeException(exc.toString());
}
}
/**
* Metodo que cria a string que deve ser mostrada para o usuario no console.
*
* @param nomeUsuario
* - Nome do usuario.
* @param mensagem
* - Mensagem enviada.
* @return Um array de bytes formatado.
*/
public static byte[] criarStringConsole(String nomeUsuario, String mensagem) {
byte[] mensagemConsole = new byte[140];
/*
* Montando uma string buffer para conter a mensagem
*/
StringBuffer stringMensagem = new StringBuffer();
stringMensagem.append("[");
stringMensagem.append(horaAtual());
stringMensagem.append("] ");
stringMensagem.append(nomeUsuario);
stringMensagem.append(" diz: ");
stringMensagem.append(mensagem);
mensagemConsole = stringMensagem.toString().getBytes();
return mensagemConsole;
}
/**
* Metodo para mostrar a hora atual no formato "HH:mm:ss"
*
* @return A hora atual formatada como HH:mm:ss
*/
public static String horaAtual() {
return new SimpleDateFormat("HH:mm:ss").format(new Date());
}
/**
* Metodo para ler uma String do teclado. Retorna a String lida ou refaz o
* metodo caso houve algum erro na leitura.
*/
public static String lerString() {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try {
String lido = br.readLine();
return lido;
} catch (IOException e) {
System.out.println("Erro ao ler a string! Digite novamente.");
return lerString();
}
}
/**
* Metodo que recebe e mostra uma mensagem, depois chama o metodo de ler uma
* nova String.
*/
public static String lerString(String mensagem) {
System.out.print(mensagem);
return lerString();
}
/**
* Metodo que verifica a existencia de mensagens pendentes. Esse metodo
* utiliza o metodo getMensagens() para esvaziar o array de mensagens caso
* exista algo. Nao retorna nada pois o que o metodo faz eh verificar as
* mensagens e ja mostra-las no console.
*/
public static synchronized void verificarMensagensPendentes(
String nomeUsuario) {
/*
* Buscando o array de mensagens pendentes
*/
LinkedList<String> mensagensParaVerificacao = new LinkedList<String>(
getMensagens());
/*
* Agui eh verificado se existem mensagens pendentes se existir, entao
* ele pegara uma a uma as mensagens ja ordenadas e mostrara no console
* para o usuario
*/
if (!mensagensParaVerificacao.isEmpty()) {
Iterator<String> i = mensagensParaVerificacao.iterator();
while (i.hasNext()) {
String textoRecebido = i.next();
/*
* Aqui eh verificado se na mensagem contem a palavra chave
* "EXIT", que indica que um usuario deseja encerrar o chat,
* tambem eh verificado se o usuario solicitante eh½ o mesmo que
* esta na maquina, para que nao exista conflito se a makina
* receber um exit de outro usuario.
*/
if ((textoRecebido.contains("[USUARIO OFFLINE]"))
&& (textoRecebido.contains(nomeUsuario))) {
System.exit(0);
} else {
System.out.println(textoRecebido.trim());
System.out.flush();
}
}
}
}
/**
* Metodo para pegar todas as mensagens pendentes. O metodo faz uma copia do
* array de mensagens e entao esvazia o array para que seja possivel receber
* novas mensagens sem existir as que ja foram lidas, sendo assim, cada vez
* que as mensagens forem pegas, nao serao mostradas as mensagens ja pegas
* anteriormente.
*
* @return Um array de todas as mensagens recebidas.
*/
public static LinkedList<String> getMensagens() {
LinkedList<String> copiaMensagensPendentes = new LinkedList<String>(
mensagensPendentes);
mensagensPendentes.clear();
return copiaMensagensPendentes;
}
/**
* Metodo para substituir o array existente por um novo array vazio para
* receber mensagens
*
* @param mensagens
* - O novo array de mensagens.
*/
public static void setMensagens(LinkedList<String> mensagens) {
mensagensPendentes = new LinkedList<String>(mensagens);
}
/**
* Metodo para armazenar uma mensagem como pendente no array de mensagens.
*
* @param mensagem
* - A mensagem para ser armazenada.
*/
public static synchronized void setMensagem(String mensagem) {
mensagensPendentes.add(mensagem);
}
}
/**
* Thread que ficara encarregada de controlar o recebimento de mensagens por
* receive. Essa Thread guarda as mensagens em um array que seria um local para
* mensagens pendentes, ainda nao lidas.
*
* @authors Vinicius Knob, Edipo Federle and Marcela Pedrini
*
*/
class GestorReceive extends Thread {
MulticastSocket socket;
String nomeUsuario;
byte[] dados = new byte[140];
DatagramPacket datagrama;
public GestorReceive(MulticastSocket skt, DatagramPacket dtg, String nmusr) {
socket = skt;
datagrama = dtg;
nomeUsuario = nmusr;
}
public void run() {
try {
/*
* Essa variavel vai controlar a vida da thread
*/
boolean viver = true;
/*
* Loop encarregado de receber mensagens e guarda-las no array de
* mensagens pendentes
*/
while (viver) {
/*
* Colocando um array de dados vazio sobre o array anterior
*/
datagrama.setData(dados);
/*
* Receive eh bloqueante
*/
socket.receive(datagrama);
dados = datagrama.getData();
String mensagem = new String(dados);
/*
* Aqui eh verificado se na mensagem contem a palavra chave
* "EXIT", que indica que um usuario deseja encerrar o chat,
* tambem eh verificado se o usuario solicitante eh o mesmo que
* esta na maquina, para que nao exista conflito se o makina
* receber um exit de outro usuario. Isso encerrara a vida da
* thread.
*/
if ((mensagem.contains("exit"))
&& (mensagem.contains(nomeUsuario))) {
viver = false;
}
MyLinkedListChatMulticast.setMensagem(mensagem);
/*
* Isso eh um bloco de limpesa do array de bytes.
*/
for (int i = 0; i < dados.length; i++) {
dados[i] = 0;
}
}
} catch (Exception exc) {
System.err.println(exc.toString());
}
}
}
Obs.: Dizem que…
- se você for um engenheiro, 3 minutos são suficientes para resolver;
- se você for um arquiteto, 3 horas;
- se você for um contador, 3 dias;
- se você for um advogado, nem em 3 meses!!
QUAL É O PRÓXIMO NÚMERO DA SEQUÊNCIA ABAIXO?
1, 2, 6, 42, 1806, _____???
‘
‘
‘
______________________________________________
¬¬’ Noosaaa, eu levei 3 segundos pra encontra o padrão!
Resposta: 3263442
Posso me considerar um nerd?
Pré-requisitos…
JDK – Que é composto pelo JRE, que por sua vez é composto pela JVM, isso será necessário já que estamos lidando com um Servidor Web para Java.
TomCat – Preferencialmente a última versão liberada.
Objetivo
Todos os posts que vi na internet ensinavam quase tudo, mas um grande problema que vi sempre foram as variáveis de ambiente. Aqui vou mostrar os passos que segui para a instalação do TomCat em um computador com Windows, onde que existe a ausencia de um instalador .exe.
Processo de Instalação
Descompactar o arquivo do TomCat baixado em C:\ e renomear a pasta resultante para “tomcat”.
Resultado: “C:\tomcat”.
Criar quatro variáveis de ambiente, para isso clique com o botão direito em Meu Computador > Propriedades > Avançado > Variáveis de Ambiente.
1. Nome: “CATALINA_HOME”; Valor: “C:\tomcat”.
ou seja, local onde foi descompactado o TomCat.
2. Nome: “CLASSPATH”; Valor: “C:\tomcat\lib\servlet-api.jar;C:\tomcat\lib\jsp-api.jar;”.
ou seja, local onde estão os arquivos .jar do Servelt e JSP.
3. Nome: “JAVA_HOME”; Valor: “C:\Arquivos de programas\Java\jdk1.6.0_16″.
ou seja, local de instalação do JDK.
4. Nome: “JRE_HOME”; Valor: “C:\Arquivos de programas\Java\jre6″.
ou seja, local de instalação do JRE.
Agora vamos criar um atalho que será o “Iniciar TomCat” e outro que será o “Encerrar TomCat” para o TomCat:
Entrar em C:\tomcat\bin e procurar o arquivo startup.bat, botão direito, Enviar para Área de Trabalho, isso criará um atalho, vá até ele, renomeie para “Iniciar TomCat”.
Procurar agora o arquivo shutdown.bat, botão direito, Enviar para Área de Trabalho, isso criará um atalho, vá até ele, renomeie para “Encerrar TomCat”.
Agora temos os atalhos para iniciar e encerrar o servidor TomCat em nossa Área de Trabalho.
OBS: Se você integrar o TomCat com alguma IDE, nao precisará desses atalhos de iniciar e finalizar, pois a IDE gerencia isso!
Após iniciar o TomCat, vá até o navegador e digite “http://localhost:8080, se aparecer a página do TomCat, é por que deu certo!
Para entender melhor a finalidade desse post é necessário entender o que é um modelo. Então eu indico a seguinte leitura como inicio:
> Construir Aplicativos Perl com o Eclipse > Usar o EPIC para Construir, Editar e Desenvolver > Modelos e Módulos:
Aqui: http://www.ibm.com/developerworks/br/library/os-perlecl/section7.html
Após a leitura você tem agora o conhecimento sobre o que pode ser feito com o plugin do EPIC no Eclipse. Agora, basta aplicar isso, então eu indico a leitura de algum site que proporcione a sintaxe de muitas coisas rotineiras da linguagem, por exemplo:
> Perl Syntax:
Aqui: http://codesyntax.netfirms.com/lang-perl.htm
Existem vários na internet, mas esse ai é bem completo. Agora então, temos que converter essa sintaxe, para a sintaxe de modelo. Abaixo listo algumas das que fiz e utilizo. São simples e muito conhecidas, mas é muito mais rápido apenas pressionar CTRL+SPACE e ter a disposição elas prontas para inserção. O caminho: Window > Preferences > Perl EPIC > Editor > Templates > New:
for($$${var},$$${var}<=$$${maxvalue},$$${var}++)
{
}
for($$${minvalue}..$$${maxvalue})
{
}
for($$${var},$$${var}<=$$${maxvalue},$$${var}++)
{
next if($$${var} == $$${value});
}
for($$${var},$$${var}<=$$${maxvalue},$$${var}++)
{
last if($$${var} == $$${value});
}
foreach $$${var} ($$@{arr})
{
}
foreach($$@{arr})
{
}
$$${var} = $$${value};
while ($$${var} < $$${maxvalue})
{
$$${var}++;
}
$$${var} = $$${value};
until ($$${var} == $$${valueCompare})
{
$$${var}--;
}
$$${var} = $$${value};
do
{
} while ($$${var} != $$${valueCompare});
$$${var} = $$${value};
do
{
} until ($$${var} == $$${valueCompare});
Bom, ai estão alguns modelos que criei, com certeza da para fazer vários além desses.
O ciclo de vida de software consiste em um cronograma lógico e aplicável a todo software existente, com menor ou maior tempo, e sua função é afirmar fases que o software passa desde seu nascimento até sua inevitável morte. O ciclo auxilia na definição dos objetivos, no fluxo de trabalho e organização do projeto como um todo. Não existe ainda uma padronização quanto à descrição exata das fases, porém duas coisas são certas: um software terá bugs e um dia terá seu fim, não há como fugir disso.
Pode-se usar como modelo para o ciclo de vida do software um onde temos fases bem definidas e que não fogem da idéia de concepção e morte, mas existem outros, o que realmente deve se levar em conta é a equipe envolvida, o conhecimento existente, tempo disponível (prazo), como o cliente é e como quer e o valor disponível para investimento. Tudo isso impacta na escolha do modelo de ciclo de vida.
Todo software inicia-se com uma definição que consiste em recolher meios para solucionar um problema existente, de forma ágil, autônoma e computacional. O que deve ser destacado aqui é que por mais bem feito que seja essa solução, alguém um dia vai olhar para isso e fazer melhor, mas enfim, tem-se a definição como o inicio para toda a dor de cabeça.
A definição vai deixar claro para todas as partes o que será feito, como será feito e o que será preciso ter para que seja feito. É a fase dos primeiros documentos para “gestação” que está por vir, ou seja, toda cerimônia de preparação e carinho na criação do filho imaculado chamado software. A única diferença com a vida real é que aqui você escolhe o sexo do filho, se bem que os avanços da ciência já permitem manipular embriões, enfim, é você que decide como ele será, e como um bom pai, você precisa carregar esse filho depois.
Terminada a escolha da mãe e as características do filho é hora de “transar”, tem-se aí o inicio do orgasmo, da tensão, do stress, da vontade, do objetivo e todo o resto que envolve a produção e desenvolvimento do software. Lembrando que se você não definiu bem a mamãe e não deu muita bola pra detalhes psicológicos ou mesmo físicos do seu filho, prepare-se, por enquanto são só rosas, mas o inferno virá.
Toda documentação será fundamental para que haja um meio de guiar a você mesmo, ou sua equipe, dependendo da complexidade da ferramenta futura influenciará totalmente no tamanho da documentação e também nos esforços em manter o máximo possível de padrões e abstrações, aquela coisa toda de qualidade e reuso tem sim muita importância, e isso reflete não só agora, mas como já foi dito, no começo são rosas, mas o inferno virá.
No caminho das índias temos agora que implementar e utilizar a padronização, codificar e testar, validar o que já foi feito, prototipar, visitar o cliente, voltar ao trabalho, consultar a bola de cristal de vez em quando e visualizar o futuro baseando-se no passado. É essa a hora de por tudo em pratica, “mãos à obra”, “let’s go!”. Não serão exatos nove meses para gestação, mas prazos devem ser criados e seguidos, e em pouco tempo, você verá seu filho correndo feliz, caindo, levantando, e todo aquele loop infinito de choradeira e amparo.
Um belo dia você acorda e percebe que seu filho cresceu e precisa levá-lo para a escola, especializá-lo em algo, torná-lo melhor, transformá-lo em algo maduro e consciente. Pois é, o software vai passar por manutenções e periódicas melhorias no código para buscar o melhor desempenho e qualidade. Parabéns! Você está no ciclo de vida do software e agora tem que conseguir ultrapassar a desgraça dos infinitos bugs e gerar novas versões, eis a evolução.
Um bom projeto de desenvolvimento não deve resultar em muitos bugs, mas sempre haverá. O software é feito por humanos e humanos erram, então temer o inevitável é ridículo, tem-se sim que enfrentar, está no sangue, ou melhor, no ciclo. A manutenção permitirá ao software aquele alongamento de vida útil citado anteriormente, trazendo um tempo maior de durabilidade no mercado. Com o tempo, não há mais muito que se fazer, pois a base também evolui, ou seja, os sistemas operacionais, ou até mesmo o hardware. Novas plataformas, novas versões e novos projetos. Recomeça a vida, vamos ao loop!
O ciclo de vida de software é isso. Um ciclo como nós temos em nossa vida, um ciclo que permite a evolução e a herança. Herdar o conhecimento do anterior é ter maior confiança para novos projetos, é saber o que fazer quando tudo parar, ou mesmo, saber onde atacar antes mesmo que tudo pare. O ciclo permite não só a evolução, assim como na realidade, ele também classifica e somente os mais fortes permanecem.
Com a crescente adoção de software pelos variados produtos no mercado, a comunidade envolvida no processo de desenvolvimento vem criando normas e padrões para projetos envolvendo o ciclo de vida. A Norma ISO/IEC 12207 é umas dessas normas e define uma forma estruturada de construir software, visando à semelhança com outras engenharias em assuntos específicos como desenvolvimento e manutenção. São 3 classes, 17 processos, 74 atividades e 224 tarefas vistas como recomendações ou requisitos para um bom ciclo de vida.
Bom, senti vontade de contribuir então, pois quando fui tentar encontrar uma IDE para Perl, e demorei pra perceber que existe, foi um tanto duvidoso o que instalar e o que usar, enfim, resolvi optar por Eclipse + EPIC, apesar da gama de tutoriais prontos para ambientes UNIX eu estou em um ambiente WIN32 e a coisa muda um pouco. Então eu vou listar alguns links úteis para quem estiver procurando pelo mesmo que eu estive:
Um vídeo de como instalar tudo e configurar:
Links:
Usei isso ai da net e já deu pra aprender como usar e iniciar, o resto é seguir o modelo “mecherico” que se aprende!! Valeu!
Iniciando meus estudos em Perl. Ai vai uma aplicação inicial: Hello World!
Atento para o detalhe que estou usando um Win32 e o programa tradutor open source é o Strawberry Perl. Esse tradutor é simples de instalar, segue a idéia de next>next>next e fim. Basta procurar na web que logo se acha para baixar.
# Primeiro programa em Perl
print “Ola Mundo!”
Até onde eu pude ler a respeito, as ultimas versões de Perl aceitam o comando “say” no lugar de “print”, mas por acaso não anotei o endereço do site, assim que encontrar escreverei a respeito!
Para executar o programa Ola Mundo! deve-se acessar o “cmd” (Iniciar, Executar, digite “cmd”). Na tela de prompt digite:
perl [endereço do arquivo]
no meu caso, eu utilizei a própria pasta que o interpretador criou no C:\ e criei uma pasta nova chamada “arquivos”. Então, ficaria assim:
perl C:\Perl\arquivos\OlaMundo.pl
A extensão “pl” se refere a arquivos perl. Usei o próprio bloco de notas e salvei como “OlaMundo.pl”.
Como ir toda vez no cmd me deixou meio ansioso, fiz então um arquivo em lote .bat para executar os testes. Ficou assim:
1. @echo off
2. ECHO.
3. ECHO EXECUTANDO: OlaMundo
4. ECHO ====================
5. ECHO.
6. perl OlaMundo.pl
7. pause
Esse arquivo .bat eu coloquei dentro da pasta “arquivos” e toda vez que quero testar, apenas altero as linhas 3 e 6 que se referem ao nome do arquivo sendo chamado pelo interpretador perl. Na linha 3 é apenas um comentário para identificação, pode ser ignorado, mas a linha 6 é o que executa o arquivo .pl. Eu chamo isso de automatização, mesmo sendo que mexer no cmd de uma certa emoção, prefiro ainda ser rápido. Esse arquivo poderia ser escrito apenas assim:
perl OlaMundo.pl
pause
O comando “pause” é um comando do prompt, não tem nada a ver com perl, mas trava a janela do cmd para visualização, se não for usado, tudo que você verá vai ser uma “piscada” de janela. Não se esqueça de salvar esse arquivos como “.bat”. O meu eu salvei como “teste.bat”.
