Archive for the 'java' Category

Groovy Beans x Java Beans

Hey! :)

Ultimamente estou encima do meu TCC mais do que nunca. Está ficando cada vez mais complicado, mais complexo, mais robusto… (ai, faltou adjetivos aí..) O pior de tudo é que realmente ainda tem muita coisa pra ser feita. o.O

Mesmo assim voltei a dar uma lidinha sobre a linguagem Groovy e achei interessante a forma com que ela trata os beans. Demorou, mas parece que todas as linguagens mais atuais notaram que fazer manualmente os getters e setters para toda variável de instância de uma classe não está com nada. Aleluia irmãos, mas existe o Eclipse pra que a gente possa gerar tudo automático. Era isso ou boa parte dos programadores Java estariam condenados a ter LER por conta do ocultamento de informação. Felizmente a linguagem Groovy reparou nesta falta de praticidade e trouxe características interessantes. Perfect! :D

GroovyBeans funcionam como os JavaBeans mas utilizando uma sintaxe mais simples (se piorasse, pra quê linguagem nova, né?!). Observe o exemplo abaixo em Groovy:

import java.util.Date

class Customer {

    Integer id
    String name
    Integer age

    static void main(args) 
    {
        def customer = new Customer(id:1, name:"Thania", age:21)
        println("Hello ${customer.name}")
    }
}

Saída:

Hello Thania

O código em Groovy acima é equivalente ao seguinte código Java:

import java.util.Date;

public class Customer {

    private Integer id;
    private String name;
    private Integer age;

    // Desce mais...

    public Integer getId() {
        return this.id;
    }

    // Mais um pouquinho...

    public String getName() {
        return this.name;
    }

    // Só mais algumas linhas...  

    public Integer getAge() {
        return this.age;
    }

    // Finalmente chegamos nos setters... 
    // Calma, a classe já tá acabando.

    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    // Sim, rola o scroll só mais um pouquinho...

    public void setAge(Integer age) {
        this.age = age;
    }

    // Ufa! Achei que não ía achar esse main nunca... 

    public static void main(String[] args) {
        Customer customer = new Customer();
        customer.setId(1);
        customer.setName("Thania");
        customer.setAge(21);

        System.out.println("Hello " + customer.getName());
    }
}

Gostei! ;)

Algumas diferenças entre Groovy e Java

Groovy tenta ser tão natural quanto possível para desenvolvedores Java. Os projetistas da linguagem Groovy partiram do princípio da “menor surpresa” quando criaram Groovy, particularmente para desenvolvedores que estão aprendendo Groovy mas estão vindo do mundo Java.

Segue uma lista de diferenças entre Groovy e Java.

1 Todos estes pacotes e classes são importados por default, isto é, você não tem que usar um import explícito para usá-los:

  • java.io.*
  • java.lang.*
  • java.math.BigDecimal
  • java.math.BigInteger
  • java.net.*
  • java.util.*
  • groovy.lang.*
  • groovy.util.*

2 == significa igualdade para tipos primitivos em Java e significa igualdade entre referências quando se trata de objetos. Para simplificar algumas bizarrices do autoboxing de Java, em Groovy == significa equals(). Se você precisa verificar a igualdade entre referências, você deve usar o método “is” como foo.is(bar).

3 “in” é uma palavra-chave, então não use isso como um nome de variável

4 Ao declarar um array, você não pode escrever:

int[] a = {1, 2, 3};

Você precisa escrever:

int[] a = [1,2,3]

5 Se você costumava escrever um loop “for” assim:

for (int i=0; i < len; i++) {...}

Tudo bem, mas você só pode usar uma única variável como contador. Uma alternativa pra este “for” seria:

for (i in 0..len-1) {...}

Ou…

for (i in 0..<len) {...}

Ou.. (esse eu sempre achei lindo em Ruby)

len.times {...}  

6 Ponto-e-vírgula é opcional. Use se você gosta. Entretanto, em alguns casos é necessário pois pode haver redundância.

7 A palavra-chave “return” é opcional.

8 Você pode usar a palavra-chave “this” dentro de métodos estáticos.

9 Métodos e classes são públicos por default.

10 Inner classes não são suportadas, mas você pode usar closures ao invés disto. :D

11 O cláusula throws na assinatura de um método não é checada pelo compilador Groovy, pois não existe diferença entre checked e unchecked exceptions.

12 Você não terá erros de compilação como você teria em Java ao usar membros indefinidos ou ao passar argumentos de tipos errados.

Enjoy!!! ;)

Fonte: http://groovy.codehaus.org/

Hello World em Java ultra-incrementado

Aqui está o mais simples e conhecido “Hello World” em Java:

public class HelloWorld 
{
    public static void main(String[] args) 
    {
        System.out.println("Hello, world!");
    }
}

Segundo Jason Tiscioni, isso não é suficientemente elegante (o.O). Sendo assim, ele implementou um “Hello World” ultra-incrementado e publicou no Slashdot. Ele utilizou os padrões Singleton, Abstract Factory, Strategy e State, todos do GoF (Gang of Four), a fim de exibir um simples mensagem de duas palavras: “Hello World!”. Apreciem:

public interface MessageStrategy 
{
    public void sendMessage();
}

public abstract class AbstractStrategyFactory 
{
    public abstract MessageStrategy createStrategy(MessageBody mb);
}

public class MessageBody 
{
    Object payload;

    public Object getPayload() 
    {
        return payload;
    }

    public void configure(Object obj) 
    {
        payload = obj;
    }

    public void send(MessageStrategy ms) 
    {
        ms.sendMessage();
    }
}

public class DefaultFactory extends AbstractStrategyFactory 
{
    private DefaultFactory() {;}
    static DefaultFactory instance;

    public static AbstractStrategyFactory getInstance() 
    {
        if (instance==null) instance = new DefaultFactory();
        return instance;
    }

    public MessageStrategy createStrategy(final MessageBody mb) i
    {
        return new MessageStrategy() 
        {
            MessageBody body = mb;
            public void sendMessage() 
            {
                Object obj = body.getPayload();
                System.out.println((String)obj);
            }
        };
    }
}

public class HelloWorld 
{
    public static void main(String[] args) 
    {
        MessageBody mb = new MessageBody();
        mb.configure("Hello World!");
        AbstractStrategyFactory asf = DefaultFactory.getInstance();
        MessageStrategy strategy = asf.createStrategy(mb);
        mb.send(strategy);
    }
}

Muito elegante e interessante, entretanto… :P

… vale ressaltar que devemos considerar os impactos da solução adotada. Ao escolhermos algum padrão que aumenta a flexibilidade do sistema, podemos deixar isto ainda mais complexo ou mais lento. Algumas das perdas geralmente valem a pena, mas subestimar alguns efeitos colaterais ao se adicionar padrões é um erro comum ao se projetar um software. :/

Pensem nisso. Patterns são muito bons, mas utilizem apenas quando realmente for preciso.

:)

Fonte: Slashdot

JBuilder, a IDE para Java do ano

A IDE JBuilder recebeu o prêmio de IDE InfoWorld Technology of Year Award 2008. Ao que consta, a InfoWorld avaliou cada IDE nas características mais básicas como facilidade de usar, integração e performance. Com o score de 8.6, a InforWorld marcou a liderança para o JBuilder no ano de 2007.

Foi citado que o JBuilder foi muito bem projetado e que tem muitas características inovadoras, que o diferenciam de muitos projetos. É muito útil para métricas e inspeção de código.

O JBuilder teve o score particularmente alto nas categorias de suporte aos diagramas de UML, suporte ao Java SE 6, suporte ao Java EE server, métricas de código e outras características de desenvolvimento colaborativo. As características que mais se destacam na ferramenta são:

  • ProjectAssist: reduz de modo dramático o tempo e a complexidade para criar novas definições de equipes e projetos.
  • TeamInsight: aperfeiçoa o desenvolvimento colaborativo com seu portal centralizado, que permite que os membros da equipe monitorem a atividade do projeto para o repositório de código fonte, acompanhando as entradas recentes, visualizando métricas de qualidade e ainda gráficos burn-down em tempo real para acompanhamento do progresso do projeto.
  • Optimizeit: fornece profiling de memória e de CPU, além de depuração – o que garante um código livre de erros.
  • Live Source UML: garante que o código e os modelos estejam sempre sincronizados.
  • Suporte a todos os servidores de aplicação incluindo Gerônimo, Glassfish, JBoss, IBM WebSphere e BEA WebLogic.

Pra quem não sabe, o JBuilder não é open source, nem sofware livre. Entretanto, Joe McGlynn (gerente da JBuilder) afirma que existe uma versão free, a Turbo JBuilder 2007. Segundo ele, esta versão fornece o ambiente de desenvolvimento fundamental do Eclipse. Além disso, pode facilmente ser aperfeiçoado com poderosas ferramentas de desenvolvimento tais como plug-ins do JGear para adicionar produtividade RAD gráfica e funções de profiling e depuração de performance e de colaboração de equipe.

Parabéns, JBuilder! :)

;)

Fonte: http://www.javalobby.org

Sun compra MySQL

Notícia quente. Pra quem não leu:

… pagando US$800 milhões cash e mais US$200 milhões em opções de ações. A MySQL AB, a empresa por trás do banco de dados open source mais popular do mundo agora está sob as asas da SUN.

Para o MySQL foi excelente, pois ele chegou em um ponto onde começa a concorrer com bancos médios, como o PostGreSQL, ou com os big players, como o DB2, SQLServer e Oracle, e embora eu seja fanboy do MySQL, tenho que reconhecer que ele SEMPRE perde jogando no campo deles.

Já em seu nicho, ele é imbatível, só dependendo de desenvolvedores decentes para criar consultas rápidas e dinâmicas. Aí nenhum dos bancos acima chega perto. (não é o caso do kernel do Drupal, lamento informar)

O valor parece alto (e é) mas é justo, e serve para desmistificar a idéia de que todo software Open Source é feito por garotos em uma garagem. A MySQL AB por exemplo tem 400 funcionários em 25 países. Isso definitivamente não é “um grupo de programadores contribuindo para um projeto em seu tempo livre”. É Business, de primeira, o que demonstra que SIM, Open Source é um modelo viável, SE for levado com seriedade e como negócio, não como plataforma ideológica ou bandeira de protesto de final de semana.

Aos usuários, uma nota de calma: NADA muda, LAMP será LAMP, no máximo LAMPJ.

Ao pessoal do Open Source, não encarem como uma derrota para as Grandes Corporações (tm Michael Moore). Pelo contrário. O MySQL tem muito a ensinar sobre o modelo, e a Sun está MESMO precisando (e aparentemente querendo) aprender. Quem sabe assim não abrem o Java de vez?

Gostei. ;~)

Fonte: Meiobit

« Página AnteriorPróxima Página »