A imposição de uma consciência ecológica

8, setembro, 2010 Sem comentários


Nos últimos dias tenho ouvido muito na mídia sobre ecologia focado em reciclagem. Um assunto tão importante como esse, é tratado aqui no Brasil como se reciclagem fosse algo que já fizéssemos há anos.
Interessante também é observar como aqueles que tentam despertar na população o interesse por esse assunto parecem realmente não considerar questões básicas em suas abordagens.

O Governo por exemplo, sugere que a dona de casa, durante sua árdua tarefa diária, separe todo lixo, cuidando em não misturar orgânicos, metais, papeis, vidros e plásticos. Até parece interessante, até você se perguntar: Como tudo isso vai funcionar? A maioria da população vive em minusculas moradias, será que caberá mais quatro recipientes de lixo numa casa? E o pior: o que adianta separar o lixo se na prática não existe coleta seletiva?

O Governo precisa iniciar projetos envolvendo a população, os condomínios, as empresas responsáveis pela coleta de lixo os sindicatos dos catadores, objetivando fazer menos propaganda e mais ação. É necessário projetar e distribuir gratuitamente um repositório de lixo compacto que seja possível num mesmo repositório, de forma prática armazenar todo tipo de lixo. E mais: é preciso fazer a coleta seletiva nesses bairros.

Algumas redes varejistas têm dado a opção de se adquirir sacolas “retornáveis”. Fico imaginando isso na prática pois à exceção do responsável pelas compras domesticas, a maioria das pessoas, não vão para o supermercado, passam lá. Imagine agora você que foi ao shopping, lembrou que precisava comprar algo mais que estava em falta mas não poderá faze-lo pois não trouxe sua sacola retornável. Se esse algo for muito importante, você poderá adquirir outra sacolinha pelos módicos R$ 4,50.

Soluções como essas nada mais são que tentativas de lançar novos produtos sob o marketing de uma
iniciativa ecologicamente correta.

Por fim não poderia deixar de mencionar a área de tecnologia que a cada dia evolui de tal forma que o mercado lança para o consumo novos produtos em intervalos cada vez menores.
No Brasil, logo teremos mais dispositivos móveis que brasileiros, ainda que esses não estejam proporcionalmente distribuídos, ou seja, não estou dizendo que todos terão um dispositivo.
Todos sabemos que não se deve descartar a baterias desses dispositivos em lixo comum, mas você conhece
algum ponto de coleta? Tipo você foi almoçar e viu a placa: “Descarte suas baterias de celulares Aqui!”.
Você não precisou ligar para nenhuma agência regulamentadora, não precisou ameaçar o gerente de uma revendedora de aparelhos celulares…

É preciso haver compreensão que apenas marketing não é suficiente para haja um despertamento de uma consciência ecológica.

Categories: geral Tags:

Groovy, o melhor dos mundos

22, setembro, 2008 Sem comentários

groovy

groovy


Uma das coisas que mais interessante na plataforma Java é a capacidade de expandir e adaptar-se às novas necessidades do mercado.
Nestes últimos anos a plataforma Java tem crescido e atraído para perto de comunidades tradicionais e sólidas como PHP, Ruby, Python devido a novos recursos de Scripting. Paralelo a essa revolução, a comunidade Groovy já estava um passo à frente pois se antecipava nos conceitos e introduzia na plataforma um novo modelo de programação cujos principais objetivos era ser simples, dinâmica, eliminar a burocracia sintática, mas aproveitar todo o poder da plataforma.
Nasceu então o Groovy uma linguagem de script espetacular sendo inspirada em outras bem sucedidas como Python, Ruby e Smalltalk.

Instalação
A instalação do Groovy é bastante simples faça o download da versão estável e descompacte o zip numa pasta desejada. Na página de downloads você também encontrará versões empacotadas para distribuições OpenSuse, Ubuntu e para quem usa Windows há um instalador próprio.
Você precisa ter o java previamente instalado e a variável JAVA_HOME configurada. Após descompactado o pacote, configure a variável GROOVY_HOME apontando para a pasta recém criada. Adicione à variável PATH a pasta bin de sua pasta $GROOVY_HOME/bin

Executando
Se tudo foi feito certinho, quando você for ao console e digitar groovyConsole você terá uma tela semelhante a esta

Você poderia também usar o groovysh, uma ferramenta interativa e muito leve. Mas groovyConsole é mais amigável

Hello Word
Abra o groovyConsole e digite área reservada ao script:

def hw = "Hello, World!"
"Sobre Isso: ${hw}"
"Sobre Isso: ${hw}".center(40,'+')

A primeira linha define a variável hw com o conteúdo “Hello, World!”, a segunda demonstra a utilização de GStrings que são Strings com recursos adicionais. Por fim, o mesmo texto é centralizado e num comprimento de 40 caracteres plus.

Num próximo post veremos o poder do Groovy em coisas mais interessantes.

Categories: Groovy Tags:

GWT – basico, mas funcional

2, setembro, 2008 Sem comentários

O GWT é um tecnologia extraordinária. Ela possibilita que aplicações sejam criadas em java e após compilado, transformado em JavaScript gerando assim uma aplicação dinâmica e bastante flexível.
A internet está cheia de tutorias e o próprio site do GWT somado ao grupo oficial de usuário é uma fonte excelente de informação para tirar dúvidas e melhorar o conhecimento.

Um problema que é muito comum nos vários tutoriais que vemos pela internet é que eles não são completos o suficientes para o usuário mais iniciante ter um compreensão da tecnologia e muitas vezes até desmotiva a continuidade em busca de um maior entendimento ante os primeiros desafios.

Para quem está iniciando uma boa alternativa é utilizar o Netbeans com seu plugin gwt4nb para GWT pois ele permite criar uma aplicação completa inclusive fazer deploy para seu servidor de aplicação.
Para o Eclipse, entretanto, não existe nenhuma boa alternativa livre (que eu conheça) para se trabalhar com o GWT, mas isso pode ser contornado de forma simples. Vamos lá:

Faça o download:
wget http://google-web-toolkit.googlecode.com/files/gwt-linux-1.5.2.tar.bz2
veja opções para outras plataformas em http://code.google.com/webtoolkit/versions.html

Descompacte o arquivo:
tar -xjvf gwt-linux-1.5.2.tar.bz2

download

Edite suas variáveis de ambiente criando a variavel para GWT_HOME e atualizando a variável PATH.
Em sistemas no padrão Linux basta editar o arquivo oculto chamando .profile em sua pasta pessoal adicionando as seguintes linhas

export GWT_HOME=/home/paulo/gwt-linux-1.5.2
export PATH=$PATH:$GWT_HOME

Lógico que você precisará substituir /home/paulo/gwt-linux-1.5.2 pela pasta onde você descompactou o gwt.
Em sistemas Windows o procedimento é realizado editando-se as propriedades do sistema conforme imagem abaixo:

variaveisWin

Criando um projeto para teste

O objetivo do nosso teste é apenas criar um esqueleto de uma aplicação padrão, acrescentando a ela uma serviço RPC e por
fim fazer o deploy num conteiner web, no nosso caso, para simplificar, o Tomcat, mas não é preciso nenhuma mudança para que este rode no Glassfish

no console digite:

cd workspace/
applicationCreator -out gwtWebMode -eclipse gwtWebMode br.com.sample.client.GwtWebMode

o gwt criou uma estrutura básica para trabalharmos. Normalmente usaríamos um outro recurso do gwt que é criar um projeto para o eclipse, com o comando projectCreator importando-o em seguida mas não vamos fazê-lo pois o projeto criado não gera os artefatos para uma aplicação web coisa que uma aplicação gwt é por natureza.

applicationCreator

O que vamos fazer é pedir para o Eclipse criar um novo projeto web justamente na pasta recém criada, isso aproveitará os arquivos criados pelo applicationCreator e nos dará os artefatos adicionais.

Abra o Eclipse e escolha File/New/Other/Dynamic Web Project
newProject

Digite o nome do projeto igual ao nome ao informado ao applicationCreator.
nameApplication

Sua aplicação já deverá funcionar em hosted mode. Experimente executar GwtWebMode-shell (está na pasta recém criada).

hostmode

O hostmoded é uma opção rápida para utilização durante a fase de desenvolvimento, mas nem todos os recursos que sua aplicação irá precisar são suportados.

Executando em WebMode

O que vamos fazer é criar um mecanismo capaz de compilar nossa aplicação e fazer o deploy dela em nosso servidor web. A melhor opção ainda é utilizar um script Ant

salve o arquivo abaixo na raiz de seu projeto com o nome build.xml

< ?xml version="1.0" encoding="UTF-8"?>


	
	

	
		
		
		
		
		
		
			
		

	

	
		
		
		
		

		
	

	
		
	

	
		
		
	

	
		
		
			
			
			
		
		
			
		
	

	
		
	

	
		
			
			
			
		
	

	
		
		
		
	

	
		
		
			
			
			
			
				
			
			
		
		
			
			
		
		
			
		




		
			
		
	

	
		
	

	
		
	

	
		
		
		

			
			
			
			
			

			
				
				
				
			

			
			
			
			
			
		
	


salve também esse arquivo de propriedades na mesma pasta com o nome build.properties

gwt.dir=/home/paulo/gwt
web.dir=${basedir}/WebContent
module=GwtWebMode
package=br.com.sample
url=http://localhost:8080/${ant.project.name}/${package}.${module}/${module}.html
war=${ant.project.name}.war

app.server.dir = /home/paulo/bin/apache-tomcat
app.server.deploy.dir = ${app.server.dir}/webapps
app.server.lib.dir = ${app.server.dir}/lib
gwt-security=OBFUSCATE

Não vou entrar nos detalhes dos arquivos.
O Eclipse deve está se “queixando” que não conhece as classes do GWT. Para resolver este problema copie os arquivos
$GWT_HOME/gwt-user.jar
$GWT_HOME/gwt-dev-linux.jar
$GWT_HOME/gwt-servlet.jar

para a pasta: gwtWebMode/WebContent/WEB-INF/lib e dê um refresh em seu projeto.

Certifique-se que o Tomcat esteja instalado e em execução.
Abra o arquivo build.properties e altere as variáveis gwt.dir e app.server.dir para refletir sua instalação
gwt.dir=/home/paulo/gwt-linux-1.5.2
app.server.dir = /home/paulo/bin/apache-tomcat

Edite seu arquivo web.xml modificando a tag welcome-file

welcome

Clique com botão direito no arquivo build.xml e escolha Run As/Ant Build. Após concluindo abra o browse no seguinte endereço:

http://localhost:8080/gwtWebMode/

webmode

Incluindo um Serviço RPC

Um outro importante recurso do GWT é a possibilidade de executar serviços remotos. Esses serviços são servlets especiais que fazem ponte entre o javascript gerado e a parte servidora, possibilitando assim um completa integração com outras aplicações e os mais variados frameworks que somos dependentes.

O nosso serviço apenas receberá uma String e retornará a quantidade de caracteres deste.
inicie criando a interface StringLengthService. Ela precisa estender a interface RemoteService.

interface

package br.com.sample.client;

import com.google.gwt.user.client.rpc.RemoteService;

public interface StringLengthService extends RemoteService {
	  public Integer length(String string);
}




Em seguida você precisa de uma outra interface que permitirá invocar os serviços de forma assíncrona, ou seja ele será executado em background e comunicado assim que houver uma “resposta” da execução do serviço.


package br.com.sample.client;

import com.google.gwt.user.client.rpc.AsyncCallback;

public interface StringLengthServiceAsync {
	  void length(String string, AsyncCallback async);
}

Por fim criaremos a classe responsável por implementar o serviço: Ela deve estender RemoteServiceServlet, implementar a interface StringLengthService anteriormente criada e deve ficar no

package br.com.sample.server

serviceimpl


package br.com.sample.server;

import br.com.sample.client.StringLengthService;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;

public class StringLengthServiceImpl extends RemoteServiceServlet implements
		StringLengthService {

	@Override
	public Integer length(String string) {
		if (string != null)
			return string.length();
		return 0;
	}

}

Declando os Serviços

Aqui está um ponto crucial na execução de serviços RPC. Caso seu interese seja apenas executar seu serviço em hosted mode basta editar o arquivo GwtWebMode.gwt.xml declando nele seu serviço:

    	

Só que não bastará isto para utiliza-lo em webmode. Você precisará declara-lo no arquivo web.xml como se faz com qualquer servlet.

servletmap

Utilizando o Serviço

Por fim faremos agora a utilização do serviço. Crie uma referência ao serviço da seguinte forma:

		this.lengthService = (StringLengthServiceAsync) GWT.create(StringLengthService.class);
		((ServiceDefTarget) lengthService).setServiceEntryPoint(GWT.getModuleBaseURL()+ "/StringLength/StringLengthService");

Veja o código completo: GwtWebMode.java

package br.com.sample.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.rpc.ServiceDefTarget;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.DialogBox;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.TextBox;
import com.google.gwt.user.client.ui.VerticalPanel;
import com.google.gwt.user.client.ui.Widget;

/**
 * Entry point classes define onModuleLoad().
 */
public class GwtWebMode implements EntryPoint {

	private StringLengthServiceAsync lengthService;

	/**
	 * This is the entry point method.
	 */
	public void onModuleLoad() {

		// prepara o serviço
		this.lengthService = (StringLengthServiceAsync) GWT.create(StringLengthService.class);
		((ServiceDefTarget) lengthService).setServiceEntryPoint(GWT.getModuleBaseURL()+ "/StringLength/StringLengthService");

		Image img = new Image("http://code.google.com/webtoolkit/logo-185x175.png");
		Button button = new Button("length");
		img.getElement().setId("pc-template-img");

		final TextBox textBox = new TextBox();
		final Label lengthLabel = new Label();

		VerticalPanel vPanel = new VerticalPanel();
		vPanel.setWidth("100%");
		vPanel.setHorizontalAlignment(VerticalPanel.ALIGN_CENTER);
		vPanel.add(img);
		vPanel.add(textBox);
		vPanel.add(button);
		vPanel.add(lengthLabel);

		// Add image and button to the RootPanel
		RootPanel.get().add(vPanel);

		button.addClickListener(new ClickListener() {
			public void onClick(Widget sender) {
				lengthService.length(textBox.getText(),
						new AsyncCallback() {

							public void onFailure(Throwable arg0) {
								lengthLabel.setText("foi mal! deu erro!");
							}

							public void onSuccess(Integer arg0) {
								lengthLabel.setText("length = "	+ arg0.toString());
							}
						}

				);
			}
		});
	}
}

final

Se deseja faça o download dos fontes gwtWebMode.zip

Categories: AJAX Tags:

script para backups – parte 2

2, setembro, 2007 Sem comentários

Num post anterior eu mostrei um script genérico para realização dos backups de projetos, mas que é flexível pois permite a personalização das informações que se deseja backupear em cada projeto, a partir de arquivos de configurações.

Neste post faremos algumas pequenas modificações nele e configuraremos o agendamento para que o backup seja feito automaticamente.

As modificações consistem em remover as mensagens e diálogos gerados pelo kdialog e outras simplificações.
O novo script ficará assim:

backup.sh

[as]
#!/bin/bash
############################################
# backup de projetos
# deve ser usado em conjuto com algum arquivo de
# definicoes de backup
# por Paulo Cordeiro (paulo@link3.com.br)
# 02/09/2007
# versao 1.2
############################################

if [ “$#” -eq 0 -o ! -e “$1” ];
then
echo “execute: backup.sh arqConfig.bpk”
exit 2
else
defBackup=$1
fi

projeto=$(cat $defBackup | grep projetoNome | cut -d “=” -f 2)
descricao=$(cat $defBackup | grep descricao | cut -d “=” -f 2)
fonte=$(cat $defBackup | grep fonte | cut -d “=” -f 2)
destino=$(cat $defBackup | grep destino | cut -d “=” -f 2)
pastasPorData=$(cat $defBackup | grep pastasPorData | cut -d “=” -f 2)
data=$(date +%Y%m%d-%H%M%S)
includefile=$(mktemp /tmp/$projeto.in.XXXXXX)
excluirfile=$(mktemp /tmp/$projeto.ex.XXXXXX)

if [ “$pastasPorData” == “sim” ]
then
destino=”$destino/$projeto/$(date +%Y)/$(date +%B)/$(date +%d)”
else
destino=$destino/$projeto
fi
backup_name=$destino/$projeto-$data.tar.gz

cd $fonte

for infile in $(sed ‘/incluir-ini/,/incluir-fim/! d; ‘ $defBackup | sed ‘1d;$d’)
do
echo $infile >> $includefile
done

sed ‘/excluir-ini/,/excluir-fim/! d; ‘ $defBackup | sed ‘1d;$d’ > $excluirfile
mkdir “$destino” -p
tar -cvzf $backup_name –exclude-from=$excluirfile $(cat $includefile) > /dev/null

rm $includefile
rm $excluirfile
echo $backup_name
exit 0
[/as]

crie também esse pequeno script que será usado no agendamento:

agendamento.sh

[as]

#!/bin/bash
############################################
# agendamento de backups
# por Paulo Cordeiro (paulo@link3.com.br)
# 02/09/2007
# versao 1.0
############################################

arqConfig=arqConfiguracao.bkp
servidor=server
usuario=user
pastaRemota=/backups
# gera o backup
backupGerado=$(dpbackupAgendamento $arqConfig)

# tranfere para servidor remoto
scp -p $backupGerado $usuario@$servidor:$pastaRemota

exit 0
[/as]

É importante observar é que o comando scp faz a transferência do arquivo de forma segura por SSH. Para que ele não solicite a senha durante a transferência é preciso que previamente você gere um par de chaves com o ssh-keygen e exporte-a para o servidor. Veja como fazer isso em http://freebsd.ag.com.br/sessao10_7.html

Por fim registre o agendamento no cron. Digite “crontab -e ” e adicione as linhas abaixo:

[as]

# agendamentoBackup
0 13 * * * agendamento.sh

[/as]

Pronto, seu backup será feito todos os dias às 13h00.

Categories: geral, linux Tags:

script para backups

Uma das primícias que qualquer desenvolvedor precisa aprender é que o backup é um grande companheiro.

Seja nas horas trágicas em que seu hd queima ou até lhe roubam o laptop ou simplesmente quando você percebe que as ultimas modificações realizadas em determinado projeto ficaram pior que a versão anterior. Nessas horas não tem jeito, recorra ao backup.

Quanto se tem muitos projetos para acompanhar fica ainda mais complicado por isso é comum se utilizar scripts para automatizar esse processo. Entretanto, cada projeto tem suas particularidades de forma que ou você armazena todas as pastas do projeto ou cria um script para cada um.

O script abaixo é bastante simples e tem por diferencial utilizar um arquivo com as configurações para o projeto que se deseja backupear permitindo a personalização do backup e facilitando a manutenção do script.

backup.sh

[as]
#!/bin/bash
############################################
# backup de projetos
# deve ser usado em conjuto com algum arquivo de
# definicoes de backup
# por Paulo Cordeiro (paulo@link3.com.br)
# 20/07/2007
# versao 1.1
############################################
clear

if [ “$#” -eq 0 -o ! -e “$1” ]
then
kdialog –yesno “O arquivo com as definições do backup não existe ou não foi informado. \n Deseja informa-lo agora?”
resposta=$?
if [ “$resposta” = “0” ]
then
defBackup=$(kdialog –getopenfilename “$HOME” \ “*.bkp |Definicoes de Backup”)
if [“$defBackup” == “”]; then exit 2; fi
else
exit 2
fi
else
defBackup=$1
fi

projeto=$(cat $defBackup | grep projetoNome | cut -d “=” -f 2)
descricao=$(cat $defBackup | grep descricao | cut -d “=” -f 2)
fonte=$(cat $defBackup | grep fonte | cut -d “=” -f 2)
destino=$(cat $defBackup | grep destino | cut -d “=” -f 2)
pastasPorData=$(cat $defBackup | grep pastasPorData | cut -d “=” -f 2)
data=$(date +%Y%m%d-%H%M%S)

echo “projeto —> $projetoNome”
includefile=$(mktemp /tmp/$projeto.in.XXXXXX)
excluirfile=$(mktemp /tmp/$projeto.ex.XXXXXX)

echo include = $includefile

if [ “$pastasPorData” == “sim” ]
then
destino=”$destino/$projeto/$(date +%Y)/$(date +%B)/$(date +%d)”
else
destino=$destino/$projeto
fi
backup_name=$destino/$projeto-$data.tar.gz

cd $fonte

echo “===========================================================================================”
echo “Backup do $projeto – $descricao”
echo “===========================================================================================”

for infile in $(sed ‘/incluir-ini/,/incluir-fim/! d; ‘ $defBackup | sed ‘1d;$d’)
do
echo $infile >> $includefile
done

sed ‘/excluir-ini/,/excluir-fim/! d; ‘ $defBackup | sed ‘1d;$d’ > $excluirfile

echo pasta $destino
mkdir “$destino” -p

xterm -e tar -cvzf $backup_name –exclude-from=$excluirfile $(cat $includefile)

echo “===========================================================================================”
echo “Backup gerado em $backup_name”
echo “===========================================================================================”

kdialog –msgbox “Backup gerado em $backup_name”

rm $includefile
rm $excluirfile

exit 0
[/as]

Cada projeto precisa ter um arquivo com as os dados para backup:

projeto1.bkp

[as]
projetoNome=projeto1
descricao=Descricao para o projeto1
fonte=/home/paulo/projetos/projeto1
destino=/backup/projetos/projeto1
pastasPorData=sim

[incluir-ini]
pasta1
pasta2
docs
pasta3
[incluir-fim]

[excluir-ini]
*.exe
*.zip
*.svn
*.class
*.~*
[excluir-fim]
[/as]

a utilização é: backup.sh projeto1.bkp

O script utiliza duas chamadas ao kdialog do KDE que podem ser trocadas pelo xdialog ou simplesmente ser removidas.

Depois explicarei alguns detalhes do script e mostrarei como agendar backup automático para um servidor remoto.

Categories: linux Tags:

ICEFaces, Ajax e JSF 1.2

O pessoal da ICESoft anunciou o release 1.6 do ICEFaces. O ICEFaces é um conjunto de componentes ricos para desenvolvimento web com JSF e AJAX.

Há alguns meses atrás tentei usa-lo em um novo projeto, mas desisti ao perceber que não poderia usa-lo junto com o glassfish. Essa incompatibilidade deve-se ao fato de o glassfish usar o JSF 1.2 por padrão e o ICEFaces a versão 1.1. Agora essa incompatibilidade acaba pois uma das novidades dessa nova versão é justamente a compatibilização com o JSF 1.2. Além desta, outras melhorias foram feitas como integração ao JBoss Seam 1.2.1, Liferay Portal, Webtide Jetty, dentre outras.

Categories: AJAX Tags:

Recuperando um datasource no Glassfish a partir de um cliente desktop

No post anterior falei como recuperar um datasource no Glassfish a partir de um client web. Hoje faleremos como fazer a mesma coisa. só que a partir de um client desktop.

O processo consiste em iniciar o contexto com atributos adicionais que auxiliem a aplicação a procurar de forma correta e encontrar o recurso solicitado.

public javax.sql.DataSource getDataSource() {
try {
Properties props = new Properties();
props.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.enterprise.naming.SerialInitContextFactory");
props.setProperty(Context.URL_PKG_PREFIXES, "com.sun.enterprise.naming");
props.setProperty(Context.STATE_FACTORIES, "com.sun.corba.ee.impl.presentation.rmi.JNDIStateFactoryImpl");
// servidor
props.setProperty("org.omg.CORBA.ORBInitialHost", "localhost");
// porta do servidor
props.setProperty("org.omg.CORBA.ORBInitialPort", "3700");
InitialContext initialContext = new InitialContext(props);
DataSource datasource = (DataSource) initialContext.lookup("jdbc/seuDataSource");
return datasource;
} catch (NamingException ex) {
ex.printStackTrace();
return null;
}
}

Os atributos:

props.setProperty("org.omg.CORBA.ORBInitialHost", "localhost");
props.setProperty("org.omg.CORBA.ORBInitialPort", "3700");

são opcionais e só precisam ser utilizados se o servidor estiver em um endereço diferente do cliente ou porta for diferente da padrão.

Algo que é importante observar é que é necessário que o classpath da aplicação client esteja configurado com os seguintes pacotes:

$GLASSFISH_HOME/lib/appserv-admin.jar
$GLASSFISH_HOME/lib/appserv-rt.jar
$GLASSFISH_HOME/lib/install/applications/jmsra/imqjmsra.jar
$GLASSFISH_HOME/lib/javaee.jar

além, é claro, do pacote com o driver JDBC para banco de dados que você está tentando acessar.

Categories: java Tags:

Recuperando um datasource no Glassfish

Quando se está trabalhando com um servidor de aplicações, é comum a necessidade de se acessar diretamente os recursos do banco de dados.

Mesmo quando se está usando frameworks de persistência como JPA ou mesmo Entities Beans pode-se haver a necessidade de fazer alguma consulta direta ao banco de dados. Nesse caso a melhor opção recuperar o datasource registrado no servidor.

Os passos são os seguintes:
No arquivo web.xml registre o recurso que deseja recuperar:


jdbc/seuDataSource
javax.sql.DataSource
Container
Shareable

Após isso só é necessário buscar no contexto seu datasource. Alguma coisa mais ou menos assim:

public javax.sql.DataSource getDataSource() {
InitialContext initialContext;
try {
initialContext = new InitialContext();
DataSource datasource = (DataSource) initialContext.lookup("java:comp/env/jdbc/seuDataSource");
return datasource;
} catch (NamingException e) {
e.printStackTrace();
}
return null;
}

e para usar a conexão basta:

datasource.getConnection()
Categories: java Tags:

Sobre Isso

Sobre Isso é um espaço que disponibilizo com o objetivo de compartilhar vários assuntos do dia-a-dia de cada um de nós que está de alguma forma ligado à tecnologia. Especialmente na área de programação, falaremos sobre a plataforma Java e eventualmente outras linguagens, sempre que oportuno.

Falarei também de Linux, tentando trazer dicas que poderão facilitar a vida daqueles que por opção ou não, migraram para o mundo do Pinguim.

Outros temas que me parecerem interessantes também serão compartilhados sempre que pertinentes.

até mais.

Paulo Cordeiro

Categories: geral Tags: