Patterns Observer Entendendo
O padrão de projeto Observer permite que objetos de vários observadores ser notificado quando um objeto objeto for alterada de alguma forma. Cada observador registra com o assunto, e quando ocorre uma alteração, o assunto notifica-los todos. Cada um dos observadores é notificada em paralelo (isto é, ao mesmo tempo).
Criando uma interface sujeitas
Quando você implementar um padrão de design, muitas vezes é uma boa idéia para começar por criar uma interface para se certificar de que os objetos que você criar irão aderir ao padrão que você está tentando usar - especialmente se vários objetos estão envolvidos. Implementar essa interface - programar para uma interface, como é chamado - mantém o seu código na linha e geralmente mantém as coisas mais claras.
Quando você está colocando o padrão Observer em código, configurar uma interface ou classe abstrata para o observers- normalmente você vai ter vários observadores, e você tem que manter os métodos que implementam consistente.
Neste exemplo, você também precisa configurar uma interface para o assunto, que é o que os observadores Assistir a interface Assunto lista os métodos de assuntos deve implementar. Coloque um método registerObserver para que o sujeito pode manter o controle de observadores que querem ser registrado. Além de registrar observadores, você deve ter alguma maneira de se livrar deles, então adicionar um método removeObserver. E não há um método notifyObservers que irá notificar os observadores de alguma mudança.
interface pública Assunto
{
registerObserver public void (Observer o) -
removeObserver public void (Observer o) -
notifyObservers public void () -
}
Essa interface enumera os métodos que temas como o sistema de banco de dados deve implementar. Próximo passo: a interface para os observadores.
Criando uma interface de observador
Criando a interface Observer, implementada pelos observadores que lhes permitam receber notificações, é simples. Tudo que você precisa é um método que será chamado quando uma nova notificação está pronto (você pode chamar esse método update). Neste exemplo, você passar a operação de banco de dados que foi realizada (como em "editar", "delete", "criar" e assim por diante) e o registro que foi alterado como strings para o método de atualização.
Observer interface pública
{
public void update (operação de Cordas, ficha String) -
}
Quando os observadores implementar o método de actualização, o sujeito é capaz de passá-los o registro que tenha sido atingido e a operação que foi realizada.
Ok, você está pronto para ir. É hora de criar o objecto base de dados que vai manter o controle dos observadores e notificá-los quando houve uma mudança.
Criando um assunto
O sujeito tem de deixar observadores registrar e tem que notificá-los quando um evento ocorre. De acordo com a interface do sujeito, a três métodos de um sujeito tem de implementar nestes exemplos são: registerObserver, removeObserver, e notifyObservers. Isso é o que a classe de banco de dados faz neste exemplo.
Para manter o controle dos observadores, use um vetor Java chamado observadores, criado no construtor base de dados. (O tipo especificador aqui,
importar java.util. * -
classe pública banco de dados implementa Assunto
{
Vector privada
Banco de dados pública ()
{
observadores = new Vector
}
.
.
.
}
Quando você usa um vetor, mantendo o controle de observadores é simples. Quando um observador quer registar, ele chama o método registerObserver do sujeito, passando-se como um objeto. O assunto - um objeto da nossa classe Database - só tem a acrescentar que observador ao vetor de observadores no método registerObserver, utilizando o método add da classe Vector.
importar java.util. * -
classe pública banco de dados implementa Assunto
{
Vector privada
Banco de dados pública ()
{
observadores = new Vector
}
registerObserver public void (Observer o)
{
observers.add (O) -
}
.
.
.
}
Como sobre a remoção de um observador do vector observadores? Sem problemas. Quando você quiser remover um objeto de um vetor, você pode usar remove do vector dologia aqui está como isso funciona no método removeObserver da classe Base de dados:
importar java.util. * -
classe pública banco de dados implementa Assunto
{
Vector privada
Banco de dados pública ()
{
observadores = new Vector
}
registerObserver public void (Observer o)
{
observers.add (O) -
}
removeObserver public void (Observer o)
{
observers.remove (O) -
}
.
.
.
}
Quando o usuário realmente faz algo com o banco de dados - exclui um registro, por exemplo - ele chama o método editRecord da classe de banco de dados. Por exemplo, para excluir ficha 1, que você pode chamar esse método como este:
database.editRecord ( "delete", "ficha 1");
Aqui está o que o método editRecord parece: Quando este método é chamado, você passá-lo a operação de banco de dados que deseja realizar e o registro que você deseja trabalhar, tanto como cadeias neste exemplo. Essas cadeias são armazenados para que possam ser repassados para os observadores. Após as cordas são armazenados, o método notifyObservers, chegando próximo, é chamado para notificar todos os observadores.
importar java.util. * -
classe pública banco de dados implementa Assunto
{
Vector privada
operação-private String
gravação private String
Banco de dados pública ()
{
observadores = new Vector
}
.
.
.
(Operação de Cordas, ficha String) public void editRecord
{
this.operation = operação-
this.record = gravação
notifyObservers () -
}
}
Aqui está a carne do código, a parte que notifica cada observador que houve uma mudança: o método notifyObservers. Cada observador implementa a interface Observer deste exemplo - o que significa que tem um método de atualização - por isso notifyObservers só tem que varrer todos os observadores registados no vetor de observadores, chamando de cada um método de atualização com a operação de banco de dados e registro afetado.
importar java.util. * -
classe pública banco de dados implementa Assunto
{
Vector privada
operação-private String
gravação private String
.
.
.
notifyObservers public void ()
{
for (int loopIndex = 0- loopIndex lt; observers.size () - loopIndex ++) {
Observador observador = (observador) observers.get (loopIndex) -
observer.update (operação, ficha) -
}
}
(Operação de Cordas, ficha String) public void editRecord
{
this.operation = operação-
this.record = gravação
notifyObservers () -
}
}
Isso é tudo que você precisa para Database.java, o assunto neste exemplo. O assunto vai deixar observadores registar-se, cancelar o registro si, e ser notificado quando um registro de banco de dados foi editado (o que você faz com o método editRecord da classe de banco de dados). Tudo o que resta a fazer para obter este show na estrada é criar os próprios observadores.