GitHub

Coloquei alguns projetos no git.
tem alguns exemplos, testes...
http://www.github.com/vyudi

Vitor Yudi Hansen

Livros Java

segue alguns livros sobre java,
bem interessantes, e com preços baixos!

=D


Use a cabeça Java
http://www.submarino.com.br/produto/1/21294017/use+a+cabeca!+java?menuId=1321&franq=303806

Use a Cabela Servlets e JSP
http://www.submarino.com.br/produto/1/21489846/use+a+cabeca!+servlets+e+jsp?menuId=1321&franq=303806

Certificação Sun Para Programador Java 6 Guia de Estudo
http://www.submarino.com.br/produto/1/21498837/certificacao+sun+para+programador+java+6+guia+de+estudo?menuId=1321&franq=303806

Java Persistence com Hibernate
http://www.submarino.com.br/produto/1/1981750/java+persistence+com+hibernate?menuId=1321&franq=303806

Desenvolvendo Aplicações Web com JSP, Servlets, JavaServer Faces
http://www.submarino.com.br/produto/1/1939603/desenvolvendo+aplicacoes+web+com+jsp,+servlets,+javaserver+faces...?menuId=1321&franq=303806


Vitor Yudi Hansen

Formatar CPF

Classe para Formatar CPF


public String formatarCPF(String cpf){
if (cpf.length() < 11){
String aux = "00000000000" + cpf;
cpf = aux.substring( aux.length()-11 );
}
cpf = cpf.substring(0,3) + "." + cpf.substring(3,6) + "." + cpf.substring(6,9) + "-" + cpf.substring( cpf.length()-2 );
return cpf;
}


Vitor Yudi Hansen

Converter Caracteres HTML - JAVA

Classe que converte caracteres.

public String convertTagsHTMLCaracteres(String htmlString){

try{

htmlString = htmlString.replace("&Agrave;", "À")

.replace( "&Aacute;", "Á")

.replace( "&Acirc;", "Â")

.replace( "&Atilde;", "Ã")

.replace( "&agrave;", "à")

.replace( "&aacute;", "á")

.replace( "&acirc;", "â")

.replace( "&atilde;", "ã")



.replace( "&Ograve;", "Ò")

.replace( "&Oacute;", "Ó")

.replace( "&Ocirc;", "Ô")

.replace( "&Otilde;", "Õ")

.replace( "&ograve;", "ò")

.replace( "&oacute;", "ó")

.replace( "&ocirc;", "ô")

.replace( "&otilde;", "õ")



.replace( "&Egrave;", "È")

.replace( "&Eacute;", "É")

.replace( "&Ecirc;", "Ê")

.replace( "&egrave;", "è")

.replace( "&eacute;", "é")

.replace( "&ecirc;", "ê")



.replace( "&Igrave;", "Ì")

.replace( "&Iacute;", "Í")

.replace( "&igrave;", "ì")

.replace( "&iacute;", "í")



.replace( "&Ugrave;", "Ù")

.replace( "&Uacute;", "Ú")

.replace( "&ugrave;", "ù")

.replace( "&uacute;", "ú")



.replace( "&Ccedil;", "Ç")

.replace( "&ccedil;", "ç")



.replace( "&circ;", "^")

.replace( "&tilde;", "~")

.replace( "&167;", "º")

.replace( "&166;", "ª");

}catch (Exception e) {

e.printStackTrace();

}



return htmlString;

}

Vitor Yudi Hansen

Extrair texto pdf com JAVA

Segue um método para extrair o texto de um PDF, para utilizar este método vocês devem baixar a lib PDFBox e utilizá-la no projeto. Esta é uma das funcionalidades desta lib.

public static String getConteudo(String arquivo){

File f = new File("pdf.pdf");
FileInputStream is = null;
try{
   is = new FileInputStream(f);
}catch(IOException e){
   System.out.println("ERRO: " + e.getMessage());
   return null;
}

COSDocument pdfDocument = null;

try{

   PDFParser parser = new PDFParser(is);

   parser.parse();

   pdfDocument = parser.getDocument();

   PDFTextStripper stripper = new PDFTextStripper();

    //Aqui retorna o texto

   return stripper.getText(pdfDocument);

}catch (IOException e){
   return "ERRO: Can't open stream" + e;
}catch (Throwable e){
   return "ERRO: An error occurred while getting contents from PDF" + e;
}
  finally
{
   if (pdfDocument != null)
   {
    try
    {
     pdfDocument.close();
    }catch (IOException e){
     return "ERRO: Can't close pdf." + e;
    }
   }}}


Vitor Yudi Hansen

Lendo e Escrevendo XML, JAVA + JDOM

Uma maniera bem simples e intuitiva de manipular xml com Java. Baixe a API JDOM. vale lembrar que JDOM é uma API Java, e não um parser.

Criando XML:

package br.com.exemplo.xml;

import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.XMLOutputter;

public class CriarXml {

public static void main(String[] args) {
//Declaração dos elementos que irão compor a estrutura do documento.
Element blog = new Element("blog");
Element post = new Element("post");
Element titulo = new Element("titulo");
Element data = new Element("data");
Element conteudo = new Element("conteudo");

//"Setando" os atributos e conteúdos
blog.setAttribute("id","1");
Attribute atributo = new Attribute("Autor","Vitor Yudi Hansen");
post.setAttribute(atributo);
blog.addContent(post);
post.addContent(titulo);
post.addContent(data);
post.addContent(conteudo);

//Criando Documento com JDOM

Document doc = new Document();
doc.setRootElement(blog);

titulo.setText("Lendo e escrevendo XML");
data.setText("18/05/2011");
conteudo.setText("JDOM + JAVA!");

try{
//escrevendo no Doc
XMLOutputter out = new XMLOutputter();
java.io.FileWriter writer = new java.io.FileWriter("exemplo.xml");
// Caminho físico do arquivo, outro ex: "C://exemplo.xml"

out.output(doc, writer);
writer.flush();
writer.close();

}catch(Exception e){
e.getMessage();
}
}
}
Lendo XMl:

package br.com.exemplo.xml;

import java.io.File;
import java.util.Iterator;
import java.util.List;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;

public class LendoXml {

public static void main(String[] args) {
try{
//Aqui você informa o nome do arquivo XML.
File f = new File("exemplo.xml");
//Criamos uma classe SAXBuilder que vai processar o XML
SAXBuilder sb = new SAXBuilder();
//Este documento agora possui toda a estrutura do arquivo.
Document d = sb.build(f);
//Recuperamos o elemento root
Element blog = d.getRootElement();
//Recuperamos os elementos filhos (children)
List elements = blog.getChildren();
Iterator i = elements.iterator();

while (i.hasNext()) {
Element element = (Element) i.next();
System.out.println("Post:"+ element.getAttributeValue("Autor"));
System.out.println("Titulo:"+ element.getChildText("titulo"));
System.out.println("Data:"+ element.getChildText("data"));
System.out.println("Conteudo:"+ element.getChildText("conteudo"));
}
}catch (Exception e) {
}
}
}



Vitor Yudi Hansen

Executando mais de um thread ao mesmo tempo

//file VariasThreads.java
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;

class Escrita implements Runnable {
 private int i;
 private static int cont=0;
 private int identificacao;
 static JTextArea textArea = new JTextArea(20,60);
 static JScrollPane scroller = new JScrollPane(textArea);
 
 public void run() {
  while(true) {
   String result = ("Thread Número (" + identificacao + ") " + i ++ + "\n");
   VariasThreads2.escreveResultado(result);
   try {
    Thread.sleep(500); 
   }
   catch(InterruptedException e) { }
  }
 } 
 
 public Escrita() {
  cont++;
  identificacao = cont; 
 }
}

public class VariasThreads2 {
 static JTextArea textArea = new JTextArea(10,20);
 static JScrollPane scroller = new JScrollPane(textArea);
 
 public static void main(String[] args) {
  new Thread(new Escrita()).start();
  new Thread(new Escrita()).start();
  JOptionPane.showMessageDialog(null, scroller, "Várias Threads 2", JOptionPane.PLAIN_MESSAGE); 
 }
 
 public static void escreveResultado(String result) {
  textArea.append(result);
 }
}

Vitor Yudi Hansen

Validar Cpf e CNPJ

public class CNP {
private static final int[] pesoCPF = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2};
private static final int[] pesoCNPJ = {6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};

private static int calcularDigito(String str, int[] peso) {
int soma = 0;
for (int indice=str.length()-1, digito; indice >= 0; indice-- ) {
digito = Integer.parseInt(str.substring(indice,indice+1));
soma += digito*peso[peso.length-str.length()+indice];
}
soma = 11 - soma % 11;
return soma > 9 ? 0 : soma;
}

public static boolean isValidCPF(String cpf) {
if ((cpf==null) || (cpf.length()!=11)) return false;

Integer digito1 = calcularDigito(cpf.substring(0,9), pesoCPF);
Integer digito2 = calcularDigito(cpf.substring(0,9) + digito1, pesoCPF);
return cpf.equals(cpf.substring(0,9) + digito1.toString() + digito2.toString());
}

public static boolean isValidCNPJ(String cnpj) {
if ((cnpj==null)||(cnpj.length()!=14)) return false;

Integer digito1 = calcularDigito(cnpj.substring(0,12), pesoCNPJ);
Integer digito2 = calcularDigito(cnpj.substring(0,12) + digito1, pesoCNPJ);
return cnpj.equals(cnpj.substring(0,12) + digito1.toString() + digito2.toString());
}

public static void main(String[] args) {
System.out.printf("CPF Valido:%s \n", CNP.isValidCPF("01115375502"));
System.out.printf("CNPJ Valido:%s \n", CNP.isValidCNPJ("13642634756318"));
}
}


Vitor Yudi Hansen

Importar e Exportar arquivo .txt

Código para Ler arquivo .txt
ou gravar!



import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import javax.swing.JOptionPane;
public class ManipularArquivo {
    public static  void arquivoSalvar(String endereco, String nome, String conteudo) throws IOException{
        File diretorio = new File("endereco");
        diretorio.mkdir();
       
        if (diretorio.isDirectory()){
        FileWriter arquivo = new FileWriter(endereco+Nome+".txt", false);
        arquivo.write(conteudo);
        arquivo.close();
       
        }
    }
    public static String arquivoAbrir() throws IOException{
        FileReader arquivo = new FileReader("ArquivoSalvo");
        String conteudo = "";
        int i;
        while ((i = arquivo.read())!=-1) {
            conteudo += (char)(i);
        }
       
        arquivo.close();
        return conteudo;
    }
}



Vitor Yudi Hansen

Livre-se do SQL

Introdução

Hibernate é um mecanismo bem simples e poderoso que permite a persistência de objetos em banco de dados relacionais de maneira transparente e para qualquer tipo de aplicação Java (seja ela web-based ou desktop-based). Ou seja, ao invés de perder tempo escrevendo SQL, misturando estas consultas no meio do seu código Java e ficar mapeando o resultado de suas consultas para objetos, com o Hibernate você vai precisar se preocupar somente com seus objetos. Além disso, o processo de desenvolvimento usando Hibernate é muito mais simples do que usar JDBC puro. Com Hibernate, você só tem estes 5 passos:

criar a tabela no seu banco de dados onde os objetos vão persistir;

criar o objeto cujo estado vai ser persistido;

criar um XML, que relaciona as propriedades do objeto aos campos na tabela

criar um arquivo contendo as propriedades para que o Hibernate se conecte ao bando de dados

criar a classe DAO que vai persistir seu objeto; Simples? Muito. Então vamos por nossos dedos para trabalhar um pouco. Para o exemplo deste tutorial, estarei usando o como banco de dados o MySQL, mas pode ser substituído por qualquer um da sua preferência. O Hibernate pode ser encontrado no endereço http://hibernate.sf.net; A versão usada neste exemplo é a 1.2.4

Criando a tabela e a classe

Vamos começar definindo uma tabela simples no banco de dados.

CREATE TABLE 'amigos'(
'nome' varchar(40) NOT NULL DEFAULT '',
'endereco' varchar(60) NOT NULL DEFAULT '',
'fone' varchar(11) DEFAULT NULL,
'cel' varchar(11) DEFAULT NULL,
'email' varchar(70) DEFAULT NULL,
'nascimento' datetime DEFAULT NULL,
PRIMARY KEY  (`nome`)
);

nota: esse passo pode ser pulado, se você utilizar as ferramentas que acompanham o Hibernate, que já geram o código de criação das tabelas (SchemaExport). Pronto. Uma tabela para que eu possa guardar os dados dos meus amigos, como se fosse uma agenda. Agora vamos para o próximo passo, que é a reprensentação disso em forma de objeto em Java. Como o Hibernate trabalha através de reflexão para fazer o mapeamento, temos que "beanificar" nosso objeto. Assim:

public class Amigo {
private String nome;
private String endereco;
private String telefone;
private String celular;
private String email;
private java.util.Date nascimento;
 
public Amigo() {
}
 
public String getNome(){
return nome;
}
 
public void setNome(String nome){
this.nome = nome;
}
 
// os outros métodos get/set vão aqui...
 
public java.util.Date getNascimento(){
return nascimento;
}
 
public void setNascimento(java.util.Date nascimento){
this.nascimento = nascimento;
}
 
}

Nada muito complicado até aqui, certo? Criamos uma tabela e um bean que "representa" o esquema desta nossa tabela. Então nos falta informar ao Hibernate como juntar os dois. Para fazermos isso, é preciso criar um arquivo de mapeamento, cujo nome deve ser sempre "NomeDoObjeto.hbm.xml" (no nosso caso, "Amigo.hbm.xml"); cada objeto a ser persistido tem seu próprio arquivo de mapeamento.

O XML que faz o mapeamento
O modelo para o nosso Amigo.hbm.xml segue abaixo:

Coisas para as quais deve se ter atenção:

o atributo "name", da tag "class" - o valor de "name" inclui o nome completo do objeto, incluindo seu package (ou seja, x.y.z.MeuObjeto). É nesta tag que dizemos qual tabela se relaciona com qual objeto (através do atributo "table");

a tag "property" - o atributo "name" se refere à propriedade no nosso Bean, enquanto o atributo "column" se refere à coluna no nosso banco de dados (este última é opcional: se você deixá-la em branco, o Hibernate vai procurar por uma coluna cujo nome seja igual ao da propriedade do seu bean). O atributo "type" também é opcional e se refere ao tipo de dado da propriedade do seu bean;

a tag ID - sim, tem a ver com o mapeamento da chave primária da sua tabela. E o mapeamento é semelhante ao feito nas tags "property"; Agora, vamos criar o arquivo de configuração para que o Hibernate possa se conectar ao banco de dados. Este arquivo é um arquivo .properties bem comum, com os seguintes campos:

hibernate.connection.driver_class = org.gjt.mm.mysql.Driver # o driver
hibernate.connection.url = jdbc:mysql://localhost:3306/agenda # a url
hibernate.connection.username = daniel # o username
hibernate.connection.password = senha # a senha

Dê a ele o nome que você quiser (agenda.properties, por exemplo). Porém, se você der a este arquivo o nome de hibernate.properties e colocá-lo no seu classpath, o Hibernate irá carregá-lo automaticamente durante a início do programa. Até aqui temos:

uma tabela no banco de dados chamada Amigos;

um simples objeto que queremos persistir, chamado Amigo;

um arquivo para relacionar nosso objeto Amigo com a tabela Amigos;

as propriedades para que o Hibernate possa se conectar ao banco de dados;

Manipulando os dados

Agora vamos brincar de persistir, criando nosso DAO!!!

import cirrus.hibernate.*;
import java.util.Date;
 
public class AmigoDAO{
 
 private SessionFactory factory;
 
 public AmigoDAO() throws Exception{
  Datastore datastore = Hibernate.createDatastore();
  datastore.storeClass(Amigo.class);
  factory = datastore.buildSessionFactory();
 }
 
 public void insert(Amigo amigo) throws Exception{
  Session session = factory.openSession();
  session.save(amigo);
  session.flush();
  session.close();
 }
 
 public java.util.List getList(String condicao) throws Exception{
  Session session = factory.openSession();
  List amigos = session.find(condicao);
  session.flush();
  session.close();
  return amigos;
 }
 
 public Amigo retrieve(String pk) throws Exception{
  Session session = factory.openSession();
  Amigo amigo = (Amigo)session.load(Amigo.class, pk);
  session.flush();
  session.close();
  return amigo;
 }
 
 public void delete(Amigo amigo) throws Exception{
  Session session = factory.openSession();
  session.delete(amigo);
  session.flush();
  session.close();
 }
}

Bom, algumas coisas acima tem que ser ressaltadas:

em datastore.storeClass(Amigo.class);, o Hibernate assume que o arquivo de mapeamento está no mesmo diretório e possui o mesmo nome da classe Amigo. Caso algum destes requisitos não for atendido, use "datastore.storeClass();";

factory = datastore.buildSessionFactory();, aqui o Hibernate novamente assume que há um arquivo hibernate.properties no seu classpath. Senão for o caso, forneça um objeto do tipo java.util.Properties como parâmetro, contendo os dados necessários para que o Hibernate possa montar sua conexão;

session.find(condicao);: a condição é uma String que possui uma estrutura muito semelhante ao SQL e serve para que o Hibernate consiga identificar uma lista de objetos que cumpram suas exigências. A estrutura é esta:

from  in class  where

O Hibernate possui uma query language própria, orientada a objetos. Bom, este é quase um "hello world" para se trabalhar com o Hibernate. Algumas coisas, como controle de transação e foreign keys, não foram abordadas e vão ficar para um próximo tutorial. A finalidade deste aqui é só a de mostrar uma alternativa ao "JDBC puro" na construção de sistemas que precisem de banco de dados como meio de persistência. Dúvidas, críticas, erros, usem o nosso fórum. p.s.: Devido ao fato de muitos estarem usando a versão 2 do Hibernate, é preciso se atentar às mudanças entre as duas versões, como a alteração do nome dos pacotes (de cirrus.hibernate.* para net.sf.hibernate), entre outras coisas. Para maiores informações sobre como portar suas aplicações da versão 1.x.x do Hibernate para a versão 2.x.x, visite: http://hibernate.org/68.html.

Fonte: http://guj.com.br/

Vitor Yudi Hansen