No padrão Obsever você possui dois tipos de classes, as classes que desejam receber uma notificação e as classes que enviam uma notificação.
Vou te explicar o modo que utilizo o padrão, mas é bom vc entender ele.
Para maiores detalhes vc pode pesquisar aqui http://www.guj.com.br/article.show.logic?id=47 ou google tb te trará vários resultados.
Eu costumo fazer uma adaptação deste padrão, o motivo vc poderá entender aqui http://www.guj.com.br/posts/list/117731.java
Segue abaixo o modo como faço ...
Eu crio duas interfaces: Observer e Subject
public interface Observer {
/**
* Recebe a notificação da classe que está sendo observada.
* @param Object[] - notificação(s) enviada da classe observada.
* */
public void update(Object[] arg );
}
public interface Subject {
/**Adiciona as classes que devem ser notificadas.*/
public void addObserver(Observer o);
/**Remove uma determinada classe da lista de classes que devem ser notificadas.*/
public void removeObserver(Observer o);
/**
* Notifica as classes observadoras de um determinado evento.
* */
public void notifyObservers();
}
A(s) classe(s) que deseja(m) receber uma notificação, deverá(o) implementar a interface Observer.
A(s) classe(s) que irá(o) enviar uma notificação, deverá(o) implementar a interface Subject.
No seu caso, a sua tela principal que contém a tabela para listar os registros é a classe que deseja ser notificada, então ela implementa a interface Observer.
A sua tela de cadastro deverá implementar a interface Subject.
Bom.. la na sua tela de cadastro, a qual implementa a Subject, vc deve criar um ArrayList que conterá todas as classes que desejam ser notificadas:
public class ClasseQueNotifica implements Subject(){
private ArrayList<Observer> observers = new ArrayList<Observer>();
...
}
Vc ja deve saber que quando implementa uma interface vc deve implementar os métodos dela, certo?
Os métodos addObserver e removeObserver ficarão assim :
public void addObserver(Observer o) {
observers.add(o);
}
public void removeObserver(Observer o) {
observers.remove(o);
}
Lá na sua classe principal (Observadora), em algum momento (após instanciar sua classe a qual implementa Subject), você deve chamar o método addObserver passando a classe principal como parâmetro, por exemplo:
public class ClasseQueRecebeNotificacao() implements Observer(){
...
private void adicionarObserver(){
instanciaDaClasseQueNotifica.addObserver(this);
}
...
}
Sua classe que implementa Subject, sempre que desejar enviar uma notificação, deverá chamar o método notifyObservers. O método deverá ser implementado semelhante ao abaixo:
public void notifyObservers() {
Iterator i = observers.iterator();
while( i.hasNext() ) {
Observer o = (Observer) i.next();
o.update(new Boolean[]{true});
}
}
No caso acima, sempre que for chamado este método, ele enviará um boolean - true para a(s) classe(s) que está(o) esperando por uma notificação, porém vc pode fazer como quiser, mandar o que quiser, vc é quem faz sua lógica. Então, após cadastrar os dados no banco e certificar que foi sucesso, vc chama o método notifyObservers. É importante saber que a classe a qual receberá a notificação, deve conhecer o que poderá chegar para ela(nesse caso um boolean).
Este método irá chamar o método update da classe principal correto? Lá no método update vc verifica se está recebendo um boolean - true , por exemplo, se sim vc recarrega a tabela. (No caso deste exemplo que passei sempre será true) .
Um exemplo do método update:
public void update(Object[] arg) {
/*Neste caso, a classe já sabe que chegará apenas um objeto como notificação*/
if(arg[0] instanceof Boolean){
/*Se for true*/
if(((Boolean)arg[0]).booleanValue()){
preencherTabela();
}
}
}
Como já disse, a lógica vc quem faz, se puder receber mais de um objeto, ou diferentes tipos de objetos, é vc quem trata como irá controlar isso.
A princípio pode parecer um pouco confuso, mas é bem simples na verdade, e muito útil. Eu utilizo muito esse padrão.
Porém é legal vc dar uma olhada nos links que te passei ou pesquisar um pouco mais para entender melhor tudo o que te passei aqui.
