Antes de qualquer coisa temos de baixar o driver e para isso basta baixá-lo da área de drivers do site do MongoDB e adicioná-lo ao seu classpath.

Conectar ao MongoDB é bastante simples, basta instanciar a classe Mongo e depois selecionar o banco.

Mongo m = new Mongo();
// ou
Mongo m = new Mongo( "localhost" );
// ou
Mongo m = new Mongo( "localhost" , 27017 );

DB db = m.getDB( "meu_banco" );

Acredito que a parte mais complicada é transformar um documento no estilo JSON em um objeto BasicDBObject que a maioria dos métodos da API recebe. Vamos fazer um exemplo:

{
	nome : "Rodrigo",
	sobrenome : "Aramburu",
	telefone : "1234-5678",
	endereco : {
				rua : "Rua Fulano",
				numero : "221B",
				bairro : "Centro"
			}
}

Convertendo este objeto JSON para objeto Java ficaria assim:

BasicDBObject pessoa = new BasicDBObject();
pessoa.put("nome", "Rodrigo");
pessoa.put("sobrenome", "Aramburu");
pessoa.put("telefone", "1234-5678");

BasicDBObject end = new BasicDBObject();
end.put("rua", "Rua Fulano");
end.put("numero","221B");
end.put("bairro", "Centro");

pessoa.put("endereco", end);

Na linha 1 criamos um objeto BasicDBObject, na linhas 2 , 3 e 4 adicionamos os campos nome, sobrenome e telefone e seus valores. O campo endereco é um campo que o valor é um objeto incorporado então antes de adicionarmos ele devemos criar este objeto(linha 6) e incluir seus campos(linhas 7, 8 e 9). Com o objeto endereco podemos inserir no campo endereco do objeto pessoa.

Se você se perguntou e se tivesse vários telefones? Simples!

String[] tels = { "1234-5678","9898-9898" };
pessoa.put("telefone", tels);

Com o Objeto criado, inserir no MongoDB é muito simples :

DBCollection colecaoPessoas = db.getCollection("pessoas");
colecaoPessoas.insert(pessoa);

Bom depois de inserir sempre é bom buscar então vamos lá:

DBCursor cursor = coll.find();
while( cursor.hasNext() ){
        BasicDBObject pessoa = (BasicDBObject) cursor.next();
        System.out.println( "Nome: "+pessoa.getString("nome") );
        System.out.println("Sobrenome: "+pessoa.getString("sobrenome") );
        System.out.println("Telefone: "+pessoa.getString("telefone") );

        BasicDBObject end = (BasicDBObject) pessoa.get("endereco");
        System.out.println( "Rua: "+end.getString("rua") );
        System.out.println( "Numero: "+end.getString("numero") );
        System.out.println( "Bairro: "+end.getString("bairro") );
        System.out.println( "======================================" );

}

Para fazer uma consulta se utiliza o método find que retorna um DBCursor que permite iterar sobre o resultado, os métodos mais importantes são hasNext() que retorna true se tiver o próximo documento e falso se não tiver mais. E o método next() que retorna o próximo DBObjetc do qual utilizamos o método getString(“nome_campo”) ou getInteger(“nome_campo”) , getBoolean(“nome_campo”), getDouble(“nome_campo”) para pegar os dados.

E como colocamos alguns critério de busca?

BasicDBObject query = new BasicDBObject();
query.put("telefone","9898-9898");

DBCursor cursor = coll.find(query);

Para filtrar basta passar por parâmetro um objeto BasicDBObject para o método find() e podemos utilizar todos os tipos de filtros, “$in”, “$lte”, “$gt”, “$or”, “$regex”, etc…

BasicDBObject query = new BasicDBObject();

query.put("idade", new BasicDBObject().append("$gt", 18));

DBCursor cursor = coll.find(query);

O interessante no filtro $in é que podemos utilizar uma coleção:

BasicDBObject query = new BasicDBObject();
List<Integer> list = new ArrayList<Integer>();
list.add(9);
list.add(10);
query.put("idade", new BasicDBObject().append("$in", list));

Bom agora vamos deletar

BasicDBObject obj = new BasicDBObject();
obj.put("_id", new ObjectId( "4e827ca3d6340373c65e4e99" )  );
colecaoPessoas.remove(obj);

Normalmente eu prefiro deletar pelo _id e o valor deste campo é um objeto do tipo ObjectId(“id”), criar um objeto BasicDBObject para depois passá-lo de parâmetro para o método remove().

Só falta atualizar

BasicDBObject ant = new BasicDBObject();
ant.put("_id", new ObjectId( "4e8279f7d63465f846d5cea9" )  );
BasicDBObject novo =  new BasicDBObject();
novo.put("$set",  new BasicDBObject().append("idade", 16));

colecaoPessoas.update(ant, novo);

Bom era isso, até mais e obrigado pelos peixes!!!

O TcheLinux é um grupo de voluntários que desde 2006 trabalha na divulgação do Software Livre no estado do Rio Grande do Sul, através de palestras e workshops gratuitos para estudantes e demais interessados.

O evento será realizado na Escola SENAC de Uruguaiana nos dias 16 e 17 de Setembro de 2011 (sexta e Sábado).

As inscrições estão abertas: http://tchelinux.uruguaianatech.info/

Confira as listas das palestras aqui: http://tchelinux.org/site/doku.php?id=evento_uruguaiana_2011

A entrada no evento é gratuita, aos interessados em certificado é solicitado a doação de 2Kg de alimentos.

Não perca esta oportunidade.

Foi utilizada a linguagem Java já que é a que utilizamos no componente de Desenvolvimento.

O Problema foi o clássico janken-pon(Pedra Papel e tesoura) ou como chamamos “JokenPO” (pura preguiça de buscar o nome certo).

Vamos então para a retrospectiva;

PRÓS

trabalho em equipe
todo mundo participou
aula sem piadas idiotas(quase)

CONTRAS

o projetor
a mancha do projetor

Para complementar segue o código produzido

public class TesteJokenPO {

        JokenPO joken = new JokenPO();

     @Test
     public void quandoPedraPapel() {
         String retorno = joken.vencedor("pedra", "papel");
         assertEquals("papel", retorno);
     }

     @Test
     public void quandoPedraTesoura() {
         String retorno = joken.vencedor("pedra", "tesoura");
         assertEquals("pedra", retorno);
     }

     @Test
     public void quandoPapelTesoura() {
         String retorno = joken.vencedor("papel", "tesoura");
         assertEquals("tesoura", retorno);
     } 

     @Test
     public void quandoTesouraPedra(){
         String retorno = joken.vencedor("tesoura", "pedra");
         assertEquals("pedra", retorno);
     }

     @Test
     public void quandoTesouraPapel() {
         String retorno = joken.vencedor("tesoura", "papel");
         assertEquals("tesoura", retorno);
     }
     @Test
     public void quandoPapelPedra() {
         String retorno = joken.vencedor("papel", "pedra");
         assertEquals("papel", retorno);
     }
}

public class JokenPO {

    public String vencedor(String j1,String j2){

        if (((j1 == "pedra")&&(j2 == "papel"))||
            ((j1 == "papel")&&(j2 == "pedra" )))
               return "papel";  

        if(((j1 == "tesoura")&&(j2 == "pedra"))||
           ((j1 == "pedra") && (j2=="tesoura")) )
               return "pedra";  

        if(((j1 == "tesoura")&&( j2== "papel"))||
           ((j1 == "papel")&&( j2== "tesoura")))
              return "tesoura";        

              return "";

    }
}

Bom pessoal espero que esse o primeiro de muitos. Andei vendo que um pessoal esta fazendo Dojo Online quem sabe dá para fazer algo assim.

Java o Filme!!! from charlesmessias on Vimeo.

Eu sei que é meio antigo mas só hoje que fui achar um com legenda

Como você pode ver no titulo deste post vamos utilizar expressões regulares para validar nossos dados, mas que diabos é uma expressão regular? Simplificando uma expressão regular é uma série de caracteres capaz de descrever outras séries de caracteres. Complicado? Um pouco no inicio talvez, mas vamos com calma analisando um exemplo simples, um telefone por exemplo

3412-1234

Como podemos ver este dado é composto somente de caracteres numéricos e é formatado com quatro caracteres numéricos, um caractere “-” e mais quatro caracteres numéricos. Vejamos como ficaria a expressão regular que expressaria essa regra:

\d{4,4}-\d{4,4}

Esta expressão poderia descrever diversos telefones que seguirem esta regra de formatação, por exemplo os telefones abaixo:

3414-4974
9698-1101
3412-1234

e não encontraria os seguintes.

12902398
13244-54452
asdf-hjkl

Então vamos destrinchar a expressão

\d: É um meta caractere do tipo representante, que no caso representa um caractere numérico, ou seja de 0-9
{4,4}: É um quantificador ele representa quantas vezes o caractere anterior pode ser repetido, no caso no minimo quatro e no máximo quatro.
- : o caractere “-” mesmo!

Meta caractere, quantificador?

Calma não criemos pânico! Um representante é um caractere que representa uma série de outros caracteres.

Meta caracteres

\d: Um dígito
\s: Um caractere de espaço em branco
\w: Um caractere de palavra(letras, dígitos ou “_”)
. : Qualquer caractere

Um aviso importante é que para utilizá-los em uma aplicação dentro de uma String devemos escapar as barras com mais uma barra. Então para validar um número inteiro devemos utilizar a seguinte expressão:

"\\d"

Se nos interessar pesquisar por um grupo limitado de caracteres podemos especificar uma lista através de colchetes. Por exemplo a lista [abc] irá somente encontrar os caracteres “a”, “b” ou “c”

“[bcf]aixa” irá encontrar as seguintes palavras “baixa”, “caixa” e “faixa”

“Texto[1234]” irá encontrar as seguintes palavras “Texto1”, “Texto2”, “Texto3”

Também podemos especificar um intervalo de valores utilizando um hífen dentro do colchete.

“[a-z]teste” irá encontrar as seguintes palavras “ateste”, “dteste”, ”oteste”, “pteste”

Bom até agora vimos como encontrar um caractere, mas se quisermos que este caractere pudesse ser repetido inúmeras vezes? Utilizaríamos um quantificador, que é um caractere que informa quantas vezes um meta caractere pode/deve ser repetido.

Quanificadores

?: Pode se repetir 0 ou 1 vez
*: Pode se repetir uma ou várias vezes
+: Pode se repetir uma ou várias vezes
{n,m}: Pode se repetir de n até m vezes

Agora podemos criar algumas expressões um pouco mais rebuscadas, como uma para validar placas de carros:

“[a-zA-Z]{3,3}-\\d{4,4}”

Vamos analisar a expressão, temos entre colchetes duas listas que informam que só será aceito caractere de “a” até “z” tanto maiúsculo como minusculo que podem ser repetido no minimo 3 vezes e no máximo 3 vezes. Seguido deve possuir um traço e após um caractere numérico que pode se repetir no minimo 4 vezes e no máximo 4 vezes.

Agora vamos ao código Java para validar:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ValidaPlaca {

    public static void main(String args[]){
        Pattern pattern = Pattern.compile("[a-zA-Z]{3,3}-\\d{4,4}");
        Matcher matcher = pattern.matcher("ETE-1234");

        if( matcher.find() ){
            System.out.println("Encontrou");
        }else{
            System.out.println("Não encontrou");
        }
    }
}

Na linha 8 criamos um objeto Pattern que é responsável por armazenar uma expressão regular que será utilizado pelo objeto Matcher que é responsável pelas buscar.

O método find()(linha 11) retorna true se encontrar o padrão de caracteres especificado pelas expressões regulares na String passada na linha 12.

O objeto Matcher pode buscar várias ocorrências do padrão em sua String possuindo métodos para retornar estas ocorrências e e suas posições. Veja o exemplo abaixo:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ValidaPlaca {

    public static void main(String args[]){
        Pattern pattern = Pattern.compile("[a-zA-Z]{3,3}-\\d{4,4}");
        Matcher matcher = pattern.matcher("ETE-1234 ZXC-4567 cdr-0987");

        boolean b = false;
        while( b = matcher.find() ){
            if( b ){
                System.out.println( matcher.group()+" - Posição: "+matcher.start() );
            }else{
                System.out.println("Não encontrou");
            }
        }
    }
}

Você pode fazer mais uns teste com outras expressões como:

CEP

"^\\d{5,5}-?\\d{3,3}$"

E-mail(não está 100% mas dá para ter uma idéia)

"^[a-zA-Z0-9_\\.-]+@([a-zA-Z0-9]\\.)*([a-zA-Z0-9])*\\."

Uma ótima referência para aprender mais é através do Expressões Regulares – Guia de Consulta Rápida por Aurélio Marinho Jargas

Date(java.util.Date)

A classe Date armazena uma data e hora, que internamente é armazenada com um inteiro long que é o numero de milissegundos que se passou desde 01/01/1970.

Esta classe é bem simples de se trabalhar, mas muitos de seus métodos foram depreciados por não trabalhar muito bem com internacionalização e etc.

Para obter a data atual se basta criar um objeto Date sem nenhum parâmetro.

Date d = new Date();

Calendar(java.util.Calendar)

A classe Calendar sendo uma classe abstrata não pode ser instanciada com o operador new, ela deve ser criada utilizando um operador estático sobrecarregado getInstance(). Na maioria das vezes você vai receber uma instância de Java.util.GregorianCalendar.

Calendar c = Calendar.getIntance();

Com a instância de Calendar devemos configurar uma data e podemos fazer isso de duas formas:

Métodos set

c.set(ano,mes,dia);
c.set(ano,mês,dia,hora,minuto);
c.set(ano,mês,dia,hora,minuto,segundo);

Método setTime

c.setTime(new Date() );

A classe Calendar também nos fornece várias constantes que utilizaremos para manipular uma data entre elas.

Com a data devidamente configurada podemos realizar diversas operações com a data:

Para adicionar ou subtrair um dia, hora, mês ou ano utilizamos o método add. O método add aceita dois parâmetros, sendo o primeiro um constante inteira que representa a unidade da data que queremos modificar(dia, mês , ano, etc…) e o segundo quantas vezes será adicionada/subtraída esta unidade.

A unidade é informada utilizando constantes fornecidas pela classe Calendar que pode ser:

Dia:

Calendar.DAY_OF_MONTH
Calendar.DAY_OF_WEEK
Calendar.DAY_OF_YEAR

Mês:

Calendar.MONTH

Ano:

Calendar.YEAR

Hora:

Calendar.HOUR
Calendar.HOUR_OF_DAY

Segundos:

Calendar.SECOND

Veja o exemplo abaixo:

Date d= new Date();
Calendar c = Calendar.getInstance();
c.add(Calendar.DAY_OF_YEAR,5 );//adicionamos 5 dias a data aual
c.add(Calendar.MONTH,3 );//adicionamos 3 mêses a data atual
c.add(Calendar.YEAR,1 );//adicionamos 1 ano a data atual

DateFormat(java.text.DateFormat)

Bom agora sabemos como manipula datas, agora precisamos formatar a data para apresentação. A classe DateFormat nos fornece uma maneira simples de formatá-la e permite a internacionalização a partir da classe Locale.

        Date d = new Date();
        Calendar c = Calendar.getInstance();
        c.setTime(d);

        DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
        System.out.println( df.format(c.getTime()) );

Para obtermos uma String da data utilizamos o método format que retorna uma String no formato especificado no método getDateInstance(). A saída do exemplo acima será algo como 03/04/10.

A classe DateForma nos fornece vários tipos de formato para data como:

Dateformat.SHORT // 03/04/10
Dateformat.MEDIUM // 03/04/2010
Dateformat.LONG //3 de Abril de 2010
Dateformat.FULL //Sábado, 3 de Abril de 2010

Embora para muitos casos estes formatos serão suficientes algumas vezes necessitamos de uma formato vem personalizado. Isso pode ser feio através de um subclasse de DateFormat a SimpleDateFormat.

        Date hoje  = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
        System.out.println( sdf.format(hoje));

O construtor de SimpleDateFormat recebe uma String que representa o formato da data. Os símbolos utilizados para cada campo da data pode ser visto na tabela abaixo abaixo:

Como vimos o dia da semana pode ser escrito por extenso, que língua ele será utilizada? Normalmente o inglês, mas se quisermos que seja na língua de um local diferente?

Para isso utilizaremos a internacionalização com a classe Locate que recebe em seu construtor a língua e o país que queremos utilizar:

Locale brasil = new Locale("pt","br");//portugues do brasil
Locale japao = new Locale("ja");// japao

O objeto locale de Locale pode ser utilizado tanto com a classe DateFormat quanto com a classe SimpleDateFormat.

Date hoje  = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("E dd ",new Locale("pt","br"));
System.out.println( sdf.format(hoje));

DateFormat df = DateFormat.getDateInstance(DateFormat.FULL,new Locale("pt","br"));
System.out.println( df.format(hoje));

Para finalizar como covertermos uma String em um objeto Date

        Date d  = new Date();
        SimpleDateFormat df = new SimpleDateFormat("DD/MM/yyyy");
        try {
            d = df.parse("25/03/2010");
        } catch (ParseException ex) {
            ex.printStackTrace();

        }
        System.out.println( df.format(d));

O métdo parse da classe DateFormat e recebe uma string e convertepara um objeto Date

package sparta;

public class Warrior {

    public static void main(String args[]){
        Warrior w = new Warrior();
        w.run();

    }
    private void run(){
        //atenção humor nerd!!!
        boolean motherFucker = this.isSparta();

        if( motherFucker ){
            this.kickBastard();
        }else{
            this.die();
        }
    }

    private boolean isSparta() {
        return true;
    }

    private void kickBastard() {
        System.out.println("ahhhhhhh!!!!!");
    }

    private void die() {
        System.out.println("...");
    }
}

Boa sacada Henrico e Luciano!

[UPDATE]

Equipe de desenvolvimento do código espartano!

Se notarem o horário do relógio irão perceber que tinha que entregar um trabalho na segunda!

A idéia da realização do UruguaianaTECH surgiu a partir da necessidade de eventos na área de tecnologia da informação em nossa região, e principalmente para difundir a utilização do Software Livre em todos os setores de nossa comunidade.

O constante crescimento da utilização do software livre nas organizações nos últimos anos, demonstram que o reconhecimento dos benefícios é algo concreto, nosso país é considerado um dos maiores utilizadores desta tecnologia, onde também existem diversos colaboradores e mantenedores de aplicativos Livres.

Vemos na fronteira oeste, um mercado a ser explorado pois muitas organizações locais não fazem o uso de um Software Livre pelo fato de desconhecerem suas vantagens e benefícios.

Cabe a nós profissionais e estudantes da área de TI mudar este cenário, pois a evolução esta acontecendo, é nossa obrigação contribuir para que ela aconteça também em nossa cidade.

As vezes pensamos que em nossa cidade não há um mercado para os profissinais de TI, isto faz com que muitos estudantes recém formados acabem saindo de nossa cidade em busca de oportunidades, com isso nossa comunidade acaba perdendo qualidade nos serviços prestados. Com esta iniciativa esperamos demosntrar a nossa comunidade que dentro dela mesmo é possível encontrar profissionais qualificados e preparados para os desafios da área de TI.

Gostaria muito de agradecer a participação dos Professores Cidão e Humberto Moura que trouxeram um brilho a mais em nosso evento, a área de TI do Senac Uruguaiana, aos colaboradores voluntários que nos ajudaram na organização e principalmente aos nossos apoiadores, pois sem eles esta edição do Uruguaiana Tech não seria possível.

Agora fica a saudade dos bons momentos compartilhados durante o evento, o conhecimento que foi recebido e retribuido, pois como mencionei no evento: “O conhecimento é universal, nós aprendemos com alguém e é nossa OBRIGAÇÃO ensinar alguém”.

Nós nos comprometemos em levar esta causa adiante e faremos o que for necessário para alavancar nossa área de TI em nossa cidade, o sol nasce para todos e juntos faremos com que esta mudança aconteça.

#galeria pasta=”uruguaianatech”#

Com a missão de educar para o trabalho em atividades do comércio de bens, serviços e turismo, o SENAC Uruguaiana promove nos dias 26, 27 e 28 de novembro o 1° UruguaianaTech, evento que visa difundir a utilização do Software Livre nos diversos setores de nossa comunidade.

Sempre conectado às inovações do mercado e atento às novas tendências em tecnologia, o núcleo de TI do Senac Uruguaiana, ministrará palestras sobre os temas: Linux, Servidores, Segurança, Desenvolvimento de Aplicações Web e Móvel.

Esta edição contará com a presença de profissionais de destaque no mercado da Tecnologia da Informação, com ampla experiência na utilização de Software Livre em ambientes corporativos, educacionais e domésticos.

O evento será realizado no auditório do Colégio Marista Sant’Ana. As inscrições podem ser realizadas através do site ou na unidade do Senac, mediante a colaboração com um alimento não-perecível. Aos interessados na emissão do certificado, o investimento será de R$10,00.

Vejam abaixo a programação do evento. Destaque para o 1º e 2º dia onde os editores deste blog, Thiago Finardi e Rodrigo Aramburu, ministrarão palestras no evento.

Vamos lá pessoal, participem e ajudem no crescimento da área de TI em nossa cidade.

http://www.uruguaianatech.info