Framework de binding

[mmpauloPJ]

Como trabalho de conclusão na faculdade, eu desenvolvi um framework(bem
ruim, hoje percebo isso…) de binding. Seguia o modelo do Delphi, ou seja,
já nasceu antiquato. Não aceitava muito bem a utilização de objetos de
negocio(com uma gambiarra, até poderia rolar), ou seja, tinha que
basicamente trabalhar em cima de SQL mesmo. Sem falar que precisava que os
componentes visuais fossem herdados para ser compativeis com o binding,
enfim, não era nem um pouco versatil.

Testei o beans binding(JSR 295), mas o binding é feito em cima de strings…
Ou seja: Adeus refactoring, adeus code completion, adeus verificação de
erros na compilação.

Dei também uma olhada por alto no JGoodies, e ele também parece depender(menos do que o beans binding) de strings. E ainda não tive oportunidade de testar outras soluções.

Comecei a implementar uma abordagem parecida com a do beans binding,
mas evitando totalmente strings.

Seria mais ou menos assim: Para cada propriedade que você quer amarrar(por exemplo, o ‘text’ de um JTextField, o ‘name’ de uma classe “Person” qualquer, o ‘enabled’ de algum componente visual, e por aí vai) é necessario haver uma implementação da interface BindingNode que faça o acesso à classe. Como ficaria inviavel criar uma classe para cada propriedade de cada objeto de negócio, estou criando uma classe ‘Property’. Para cada objeto de negocio, é necessario ter uma classe que a escreve publicando um Property para cada propriedade(essa classe pode facilmente ser gerada de forma automatizada, o programador não precisa se preocupar com isso). Seria mais ou menos assim a abordagem das Propertys:

[code]public class Pessoa {
public String getNome() {}
public void setNome(String nome) {}
public int getIdade() {}
public void setIdade(int idade) {}
}

public class PessoaDescriptor {
public static final Property nome = new Property(…);
public static final Property idade = new Property(…);
}[/code]
Esta segunda classe serve apenas para vc poder acessar as propriedades sem usar strings.

Para coisas comuns como propriedades de componentes visuais, o framework conta com implementações especificas de BindingNode, isso permite acessar tais propriedades sem ter que se basear em reflexão. E ainda dá flexibilidade ao programador criar novos nodes que atendam às suas necessidades.

Para efetuar o binding, voce instancia dois ‘BindingNode’ e os vincula através de um objeto Binding.

No fim das contas, ficaria assim:

Pessoa p = new Pessoa(); JTextField tfNome = new JTextField(); Binding binding = new Binding(new PropertyBindingNode(PessoaDescriptor.nome, p), new JTextFieldBindingNode(tfNome));

A minha ideia principal é evitar strings… Programar baseado em strings é
pedir para ter dor de cabeça no futuro =/
Mas para quem não se sentir bem tendo que criar uma classe para cada possivel caso de binding, é teoricamente possivel criar um BindingNode que se liga a uma propriedade via reflexão, recebendo o nome dela como String, aí ficaria bem parecido com o Beans Binding (JSR 295)

Bom… Sugestões, criticas?

[mmpauloPJ]

Ok, já consegui colocar a criança para funcionar de forma bem rudimentar, aqui vai uma demonstração:

[code]import java.beans.*;

public class Teste {
private PropertyChangeSupport pcs = new PropertyChangeSupport(this);

private String propA;

public String getPropA() {
    return propA;
}

public void setPropA(String propA) {
    String old = getPropA();
    this.propA = propA;
    pcs.firePropertyChange("propA", old, getPropA());
}

public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
    pcs.addPropertyChangeListener(propertyName, listener);
}    

}[/code]
Esse é um bean normal, que usarei para testar o binding.

[code]import bindwos.beans.Property;

public class TesteDescriptor {
public static final Property<Teste, String> propA =
new Property<Teste, String>(Teste.class, String.class, "propA");
}[/code]
Essa classe define as propriedades de um bean de forma que eu possa acessa-las sem usar strings para referenciar seu nome.
Alias, aqui é o único lugar aonde se usa uma string para definir o nome de uma propriedade(tenho uma ideia +/- formada de como eliminar isso, mas não sei se compensa, visto que eu planejo que essa classe seja gerada automaticamente por uma ferramenta auxiliar).

E finalmente o bind:

Teste t = new Teste(); Teste t2 = new Teste(); BindingNode<String> b = TesteDescriptor.propA.buildBindingNode(t); BindingNode<String> b2 = TesteDescriptor.propA.buildBindingNode(t2); Binding<String, String> binding = new Binding<String, String>(b, b2); t.setPropA("Teste 1"); System.out.println(t2.getPropA()); t.setPropA("Teste 2"); System.out.println(t2.getPropA()); t2.setPropA("Teste 3"); System.out.println(t.getPropA());
Executando isso, irá aparecer na tela:
Teste 1
Teste 2
Teste 3
Indicando que as propriedades estão sincronizadas.