Integre Redes Sociais nas Nuvens com o Framework Play

30 de Julho de 2013 1 comentário

Parabéns mais uma vez aos meus parceiros Boaglio e Edu pela matéria na revista MundoJ edição de aniversário 10 anos. Dessa vez teve a foto hein… não queimou a impressão, kkkkkkkkkkkkk

Imagem

Use as redes sociais no seu sistema Play e faça o deploy nas nuvens de maneira totalmente gratuita. Por Eduardo Cerqueira e Fernando Boaglio

Aproveitando mais uma vez para dizer que passamos dos 3.400 acessos. Espero ter ajudado alguém nessa terra. rs

Anúncios

JDBC – Conexão Java + MySQL – 2ª Parte

30 de Julho de 2013 Deixe um comentário

7º Passo: Executar a aplicação.

Ao executarmos a classe TestaConexão.java o programa irá entrar no “public static void main(String[] args)” que conforme ja mencionado é o ponto inicial de execução do programa, criar uma instância na classe ConexaoManutencao através do “new ConexaoManutencao();” e depois ao entrar no try-catch que é necessário para que o código tenha uma saida em caso de erro e vai para o nosso getConexao. Seguindo o método getConexao nosso programa vai rodar o que tem lá dentro e… e… vai dar erro, putz… teremos algo assim:

java.sql.SQLException: Driver nao encontrado
	at br.com.aula.dao.ConexaoManutencao.getConexao(ConexaoManutencao.java:28)
	at br.com.aula.beans.TestaConexao.main(TestaConexao.java:20)
Caused by: java.lang.ClassNotFoundException: com.mysql.jdbc.Driver
	at java.net.URLClassLoader$1.run(Unknown Source)
	at java.net.URLClassLoader$1.run(Unknown Source)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.net.URLClassLoader.findClass(Unknown Source)
	at java.lang.ClassLoader.loadClass(Unknown Source)...

O programa vai dar erro porque falta o driver de conexão entre a aplicação e o banco de dados, mas para facilitar a vida de nós programadores, os fornecedores dos bancos de dados são obrigados, e também para não perderem mercado, a disponibilizar um driver de conexão entre seu sistema e as linguagens de programação existentes, assim temos um arquivo .jar que basta adicionar ao sistema e zás, todo o código fonte entre a Java e MySQL, por exemplo, já pronto. Então vamos ao próximo passo.

8º Passo: Baixar o driver .jar do MySQL na página: http://dev.mysql.com/downloads/connector/j/ e carregá-lo na aplicação: Botão direito do mouse sobre a aplicação –> Properties –> Java Build Path –> “Libraries” –> Add External JARS e localizar o driver, no meu caso “mysql-connector-java-5.1.25.jar”.

9º Passo: Executar novamente aplicação.

Se a conexão for bem sucedida com o banco iniciado, tabela, etc teremos o seguinte log:
Obtendo conexao…
Conexao OK!
Conexao Fechada.

Caso o banco esteja parado por algum motivo ou o servidor não esteja acessivel teremos o seguinte log:

java.sql.SQLException: Erro ao obter a conexao
	at br.com.aula.dao.ConexaoManutencao.getConexao(ConexaoManutencao.java:31)
	at br.com.aula.beans.TestaConexao.main(TestaConexao.java:20)
Caused by: java.lang.ClassNotFoundException: com.mysql.jdbc.Driver
	at java.net.URLClassLoader$1.run(Unknown Source)
	at java.net.URLClassLoader$1.run(Unknown Source)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.net.URLClassLoader.findClass(Unknown Source)
	at java.lang.ClassLoader.loadClass(Unknown Source)...

Não sei se o exemplo foi muito claro ou simples demais, a idéia foi exibir um pequeno exemplo de conexão entre o Java e o MySQL, estou a disposição em caso de dúvidas e logo postarei outros exemplos com banco de dados. Até lá.

JDBC – Conexão Java + MySQL – 1ª Parte

24 de Julho de 2013 2 comentários

Irei apresentar neste post uma forma simples de conectar a aplicação java com um banco de dados, o exemplo de banco será o MySQL que é um banco gratuito, de simples instalação e bem aceito no mercado principalmente para aplicações de baixo nivel.

1º Passo: Instalar o MySQL e criar um database. (Não faz parte do meu exemplo ensinar passo-a-passo como instalar o MySQL, mas é facilmente encontrado na internet, para download: http://dev.mysql.com/downloads/installer/). Depois criar um database. Exemplo: “Produtos”.

2º Passo: Criar um novo projeto Java. File –> new –> java project. Exemplo: “ConexãoJDBC”.

3º Passo: Criar os pacotes que terão nossas classes java. Exemplo: br.com.aula.beans e br.com.aula.dao (data access object é um design pattern para conexões a banco de dados, mas não vou aprofundar nesse assunto, o nome do pacote “dao” é apenas um exemplo).

Então temos algo assim: Imagem

4º Passo: Criar no pacote dao a classe ConexaoManutencao.java e no pacote beans a classe TestaConexao.java.

5º Passo: A classe ConexaoManutencao:

public class ConexaoManutencao {
	private static final String STR_DRIVER = "com.mysql.jdbc.Driver";
	// identificacao url do driver do banco de dados

	private static final String USER = "root"; // usuario do database
	private static final String PASSWORD = "root"; // senha do database

	private static final String IP = "localhost";
	// "localhost ou 192.168.0.1" para banco de dados em maquina local
	// ou o ip ou nome da maquina servidor de banco de dados

	private static final String DATABASE = "Produtos";
	// Nome do banco de dados que ainda nao sera usado
	
	private static final String STR_CON =
	"jdbc:mysql://" + IP + ":3306/" + DATABASE;
	// Aqui é criado uma string str_com que tem o endereco completo
	// da conexao

	public static Connection getConexao() throws SQLException {
	Connection conn = null;
	try {
		Class.forName(STR_DRIVER);
		conn = DriverManager.getConnection(STR_CON, USER, PASSWORD);
		System.out.println("Obtendo conexao...");
	return conn;
	// acima obtenho uma conexao passando os parametros do database, usuario e senha

	} catch (ClassNotFoundException e) {
		String errorMsg = "Driver nao encontrado";
		throw new SQLException(errorMsg, e);
		// acima faco uma excessao para o driver do MySQL nao encontrado
	} catch (SQLException e) {
		String errorMsg = "Erro ao obter a conexao";
		throw new SQLException(errorMsg, e);
		// acima tenho uma excessao caso dê outro problema de conexao da
		// aplicacao com o banco como problemas de rede, servico mysql parado, etc
	}
	}	
// observe que para criar uma conexao é necessário um ter um try catch
// que permite dar outra saida ao codigo em caso de erro, parecido com IF/ELSE

	public static void closeAll(Connection conn) {
		try {
			if (conn != null) {
				conn.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
// acima tenho um metodo que fecha a conexao, importante para nao ficar
// com instancias desnecessarias conectadas ao banco de dados. 
	}

6º Passo: Testar a conexão com o banco de dados, classe TestaConexao.java

public class TestaConexao {
	public static void main(String[] args) {
	// TODO Auto-generated method stub

	ConexaoManutencao cm = new ConexaoManutencao();

	Connection conn = null;
	try {
		cm.getConexao();
		System.out.println("Conexao OK!");

		cm.closeAll(conn);
		System.out.println("Conexao Fechada.");

	} catch (SQLException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	} 
}

Framework Play

20 de Março de 2013 Deixe um comentário

Parabéns aos meus colegas Eduardo Cerqueira e Fernando Boaglio pela matéria na edição de jan/fev. da revista MundoJ.

Muito sucesso a vocês, sei que não foi fácil e o processo foi lento.
Abraços

Obs.: Faltou a foto novamente, fala sério.

ed57p

IDE – Eclipse

5 de Fevereiro de 2013 Deixe um comentário

Bem agora que o básico dos básicos já esta na ponta da língua acho necessário a instalação de uma IDE para ajudar na escrita dos nossos códigos, compilar e executar os programas, digo isso visando a agilidade. Pois bem, as duas mais famosas são o NetBeans e o Eclipse, muitos programadores, professores, etc evitam fazer comparações e arriscar um palpite para dizer qual dos dois é melhor, para não ficar em cima do muro, eu que já testei ambos afirmo que é o Eclipse por alguns motivos: não precisa de instalação, é mais leve para executar, mais fácil de se obter atualizações, mais utilizado no mercado, mais fácil de configurar e instalar programas auxiliares.

A última versão lançada do Eclipse é o Juno.

Imagem

 

Para baixá-lo basta acessar o link: Eclipse e escolher o download de acordo com seu sistema operacional.

No Windows por exemplo basta extrair do zip, colocar em qualquer diretório, ex.: C:\ e clicar no executável dentro da pasta para abrir o programa da IDE ex.: C:\Eclipse\eclipse.exe.

Antes de abrir o programa o Eclipse pergunta onde é o diretório que você deseja salvar seus projetos, nos nossos exemplos é C:\Sistemas\

A missão agora é configurar o JDK que já está instalado na máquina para que o Eclipse reconheça, então acesse o caminho: Window -> Preferences -> Java -> Installed JREs, clicar em Add -> Selecionar Standart VM -> JRE Home: (apontar o caminho onde o JDK esta instalado) C:\Program Files\Java\jdk1.6.0_35 -> JRE Name: (Qualquer nome, geralmente é usado JDK+a versão do mesmo ex.: 6.0_35) -> Finish. 

Pronto seu Java já esta configurado no Eclipse.

Agora para criar um projeto basta acessar -> File -> New -> Java Project -> Nome do Projeto e next, next, next, next, next… depois é só clicar com o botão direito do mouse no projeto criado -> New Class -> Nome da Classe -> next, next, next, next, next… para executar a classe que tem o método main é só clicar com o botão direito do mouse dentro da classe -> Run AS -> Java Application.

Agora é só criar muitos pacotes, classes, etc e etc.

O Fernando Boaglio já havia publicado dois posts sobre o Eclipse. 2003: http://www.boaglio.com/index.php/tutoriais/instalando-o-eclipse-no-windows/ e 05/2012: http://www.boaglio.com/index.php/category/eclipse/

Para estudar vou deixar uma dica legal, o vídeo 025 das video-aulas que já publiquei tem um exercicio de dado interessante, tente faze-lo conforme as indicações.

Até o próximo post, vlw 🙂

Pacotes Java

19 de Janeiro de 2013 Deixe um comentário

Neste exemplo além de criar as classes em pacotes(diretórios) diferentes serão exercitados lógica, métodos, conversão de String para Integer, formatação de data e hora e importação de classes em API´s e mais O.O.

Primeiro devemos criar os diretórios, que neste exemplo será: C:\workspace\ExercicioParse\br\com\util

No diretório(pacote) util criar a classe Datas.java e no pacote br criar a classe Principal.java

Datas.java

// aqui eu indico em qual pacote esta minha classe


package br.com.util;

// aqui eu importo uma classe da API que fica no endereço indicado para formatar a data
import java.text.SimpleDateFormat;

// aqui eu importo outra classe da API que fica no endereço indicado para buscar a data e hora atual
import java.util.Date;

public class Datas {

//criando o método obterDataAtual como publico para poder utilizar em outras classes do nosso sistema
public String obterDataAtual(){
//criando um formato para minha data
SimpleDateFormat formatoBrasileiro = new SimpleDateFormat("dd/MM/yyyy");
//recebendo a data atual e colocando na variavel data
Date data = new Date();
//aqui eu pego a data, coloco no formato que foi especificado pelo meu formatoBrasileiro e retorno a instrucao
return formatoBrasileiro.format(data);
}

public String obterHoraAtual(){
//aqui crio um formato para a hora
SimpleDateFormat formatoBrasileiro = new SimpleDateFormat("hh:mm:ss");
//recebo a hora atual e coloco na variavel hora
Date hora = new Date();
//aqui eu pego a hora, coloco no formato que foi especificado pelo meu formatoBrasileiro e retorno a instrucao
return formatoBrasileiro.format(hora);
}
}

package br;

// aqui eu importo a classe que eu mesmo criei para utilizar nesta classe
import br.com.util.Datas;

public class Principal {

// metodo main que sera executado
public static void main(String[] args) {

// criando uma instancia para a classe Datas
Datas datas = new Datas();

// aqui eu exercito um exemplo real de uso, como faco para saber quantos segundos tem a hora atual, entao eu obtenho a hora atual, coloco na variavel string teste e retiro os dois pontos, exemplo de 12:34:56 ficaria: teste = 123456
String teste = datas.obterHoraAtual().replace(":", "");

// calculo dos segundos
// aqui crio a variavel que recebe os campos 5 e 6 da variavel teste atraves do comando substring
String teste1 = teste.substring(4, 6);
// abaixo eu crio uma variavel inteira que recebe a string teste1 sendo convertido atraves do comando Integer.parseInt e como resultado tenho os segundos
int seg1 = Integer.parseInt(teste1);

// calculo dos minutos
String teste2 = teste.substring(2, 4);
int seg2 = Integer.parseInt(teste2);
// abaixo eu tenho os minutos sendo multiplicados por 60 para transformar em segundos dos minutos
seg2 *= 60;

// calculo das horas
// aqui eu crio uma variavel string teste3 diretamente do metoto obterHoraAtual sem nenhum tratamento
String teste3 = datas.obterHoraAtual();
// abaixo eu crio um array com o nome de "s" que vai receber as partes da minha hora separados por dois pontos através do comando slit
String s[] = teste3.split("\\:");
// aqui eu crio a variavel inteira seg3 que vai receber a posição 0 do meu array que tem as minhas horas
int seg3 = Integer.parseInt(s[0]);
// abaixo eu tenho os minutos sendo multiplicados por 3600 para transformar em segundos das horas
seg3 *= 3600;

// abaixo eu crio uma variavel inteira com a soma de todos os segundos contabilizados
int resultado = seg1 + seg2 + seg3;

// aqui eh impresso a data atual formatada
System.out.println("A data atual é: " + datas.obterDataAtual() );

// aqui eh impresso a hora atual formatada
System.out.println("A hora atual é " + datas.obterHoraAtual() );

// aqui eh impresso a duracao atual em segundos
System.out.println("A duracao de " + datas.obterHoraAtual() + " corresponde ha " + resultado + " segundos." );
}

}

Assim teremos essa saída:
ExercicioParse
Veja que para compilar e executar as classes também tem uma diferença.

 

Para conhecer mais as classes de API´s, como utilizar e também sobre substring, split, replace etc vale a pena conferir a documentação do java 7: http://docs.oracle.com/javase/7/docs/api/ , até o próximo post.

Encapsulamento, Polimorfismo e Herança – Fase 3 – Entrada de Dados com JOptionPane

16 de Novembro de 2012 1 comentário

Até este momento todas as vezes que queremos imprimir algo como “Olá Mundo” a frase esta fixa no código, mas existem algumas formas de interação com o usuário, onde o próprio insere as informações e recebe uma resposta, assim como digitar dois números e receber a soma deles, neste post irei utilizar o JOptionPane que é uma função que o Java faz mas que fica dentro de uma biblioteca do Java, futuramente irei falar sobre bibliotecas Java e como utilizá-las, mas por enquanto vou passar apenas essa do JOptionPane que irei usar.

Todo o código será o mesmo da Fase 2, a mudança esta apenas na classe VeiculoTeste que possui nosso método “main” e que é utilizado na impressão.

import javax.swing.JOptionPane;
// aqui eu importo a biblioteca que contém o JOptionPane

public class VeiculoTeste {

public static void main(String args[]) {
// classe VeiculoTeste continua com o "main" para imprimir o resultado do meu programa.

// Imprimindo o Carro
Carro c = new Carro();

String nome = null, cavalos = null, cilindradas = null, roda = null, combustivel = null, desloca = null, volante = null, cor = null, modelo = null;
// Aqui eu crio variaveis do tipo String para receber os valores digitados

nome = JOptionPane.showInputDialog("Qual é o Nome?");
modelo = JOptionPane.showInputDialog("Qual é o Modelo?");
cor = JOptionPane.showInputDialog("Qual é a Cor?");
cavalos = JOptionPane.showInputDialog("Quantos Cavalos?");
cilindradas = JOptionPane.showInputDialog("Quantas Cilindradas?");
roda = JOptionPane.showInputDialog("Qual é a Roda?");
combustivel = JOptionPane.showInputDialog("Qual é o Combustivel?");
desloca = JOptionPane.showInputDialog("Qual é o Deslocamento?");
volante = JOptionPane.showInputDialog("Qual é o Volante?");
// Acima eu usei o JOptionPane com uma caixa de dialogo para perguntar ao usuário a descrição do Carro.

// Abaixo estou setando o que o usuário escrever dentro de cada Carro.Descrição
c.setNome(nome);
c.setModelo(modelo);
c.setCor(cor);

long cavalosLong = Long.parseLong(cavalos);
c.m.setCavalos(cavalosLong);
// Como cavalos é do tipo Long fui obrigado a converter de string para long

int cilindradasInt = Integer.parseInt(cilindradas);
c.m.setCilindradas(cilindradasInt);
// Convertendo cilindradas para Integer

c.setRoda(roda);
c.setCombustivel(combustivel);
c.setDesloca(desloca);
c.setVolante(volante);

JOptionPane.showMessageDialog(null, c);
// Aqui eu imprimo o "c" que esta no ToString da classe Carro também usando o JOptionPane

// Aqui começo a imprimir o Barco

Barco b = new Barco();

nome = JOptionPane.showInputDialog("Qual é o Nome?");
cavalos = JOptionPane.showInputDialog("Quantos Cavalos?");
cilindradas = JOptionPane.showInputDialog("Quantas Cilindradas?");
combustivel = JOptionPane.showInputDialog("Qual é o Combustivel?");
desloca = JOptionPane.showInputDialog("Qual é o Deslocamento?");
volante = JOptionPane.showInputDialog("Qual é o Volante?");

b.setNome(nome);

b.m.setCavalos(cavalosLong);

b.m.setCilindradas(cilindradasInt);

b.setCombustivel(combustivel);
b.setDesloca(desloca);
b.setVolante(volante);

JOptionPane.showMessageDialog(null, b);

}
}

Maiores detalhes sobre entrada de dados estão nas video aulas 11 e 12 do link ja postado anteriormente.
Sobre bibliotecas existe uma documentação no site da Oracle que detalha o que cada biblioteca tem, com exemplos e funções especificas.

Obs.: Este humilde blog passou dos 1.500 acessos, espero ter ajudado alguém ou pelo menos incentivado o estudo. Até o próximo post.

🙂

Categorias:Sem categoria Etiquetas:,