Renomear métodos implementados para o padrão de observador em java
-
27-09-2019 - |
Pergunta
Estou usando a interface de classe / observador observável em Java para implementar o padrão de observador. A interface do observador requer substituição do método Atualização (observável o, objeto arg).
O problema é que estou observando um número razoável de classes, e meu método update () ficou muito grande:
public class Foo implements Observer {
....
public void update(Observable o, Object param) {
if (o instanceof A) {
// large chunk of code
...
} else if (o instanceof B) {
// large chunk of code
...
}
...
} else if (o instanceof H) {
...
}
}
}
Para dividir o método, estou pensando em estender a interface do observador com a interface do EG AOBSERVER, interface bobserver. Que requer substituição do OnaUpdate, onbupdate .. respectivamente. Esse método também facilitará a determinação do que a classe está observando com base nas interfaces que está implementando.
class Foo implements AObserver, BObserver {
....
public void onAUpdate(Observable o, Object param) {
if (o instanceof A) {
// large chunk of code
...
}
public void onBUpdate(Observable o, Object param) {
if (o instanceof B) {
// large chunk of code
...
}
}
O problema é que, se eu herdar o Observer, ainda preciso implementar o método update (). Não posso renomeá -lo para OnaUpdate ou algum outro nome da minha escolha.
Algum conselho? Obrigado.
Solução
Aqui, codifiquei uma implementação bruta usando o padrão de observador e visitante. Você pode tomar isso como uma idéia para aprimorá -lo e preencher onde quer que você veja alguns buracos.
public interface IObserver extends Observer {
public void add(AbstractObservable observable, IObserverVisitor visitor);
public void remove(AbstractObservable observable);
public void removeAll();
}
public class Observer implements IObserver {
Map<AbstractObservable, IObserverVisitor> observableMap =
new HashMap<AbstractObservable, IObserverVisitor>();
public void add(AbstractObservable observable, IObserverVisitor visitor) {
observableMap.put(observable, visitor);
}
public void remove(AbstractObservable observable) {
observableMap.remove(observable);
}
public void removeAll() {
observableMap.clear();
}
public void update(Observable o, Object arg) {
observableMap.get(o).visit(this, o, arg);
}
}
public class AbstractObservable extends Observable{
public synchronized void addObserver(IObserver o, IObserverVisitor visitor) {
o.add(this, visitor);
super.addObserver(o);
}
public synchronized void deleteObservers(IObserver o) {
o.removeAll();
super.deleteObservers();
}
public synchronized void deleteObserver(IObserver o) {
o.remove(this);
super.deleteObserver(o);
}
@Override
public synchronized void deleteObserver(Observer o) {
throw new UnsupportedOperationException();
}
@Override
public synchronized void addObserver(Observer o) {
throw new UnsupportedOperationException();
}
@Override
public synchronized void deleteObservers() {
throw new UnsupportedOperationException();
}
@Override
public synchronized int countObservers() {
return super.countObservers();
}
@Override
public synchronized boolean hasChanged() {
return super.hasChanged();
}
@Override
public void notifyObservers() {
super.notifyObservers();
}
@Override
public void notifyObservers(Object arg) {
super.notifyObservers(arg);
}
@Override
protected synchronized void clearChanged() {
super.clearChanged();
}
@Override
protected synchronized void setChanged() {
super.setChanged();
}
}
public class Observable1 extends AbstractObservable {
public void changeSomething() {
setChanged();
notifyObservers();
}
}
public class Observable2 extends AbstractObservable {
public void changeSomething() {
setChanged();
notifyObservers();
}
}
public interface IObserverVisitor {
void visit(IObserver obsrvr, Observable obsrvable, Object o);
}
public class ObserverVisitor1 implements IObserverVisitor{
public void visit(IObserver obsrvr, Observable obsrvable, Object o) {
System.out.println("updated one");
}
}
public class ObserverVisitor2 implements IObserverVisitor{
public void visit(IObserver obsrvr, Observable obsrvable, Object o) {
System.out.println("updated two");
}
}
public class ObserverTest {
@Test
public void testAnything() {
Observable1 obsrvable1 = new Observable1();
Observable2 obsrvable2 = new Observable2();
Observer obsrvr = new Observer();
obsrvable1.addObserver(obsrvr, new ObserverVisitor1());
obsrvable2.addObserver(obsrvr, new ObserverVisitor2());
obsrvable1.changeSomething();
obsrvable2.changeSomething();
}
}
Espero que você não esteja perdido. :)
Outras dicas
Sugerirei criar uma interface UpdateHandler para fazer o processamento para qualquer bloco de código. Cada caso pode ser manipulado com um mapa.
Código de amostra segue -se:
// Interface to implement for each case
public interface UpdateHandler {
public void update(Observable source, Object data) ;
}
Adicione um campo de instância à sua classe principal da seguinte forma:
private Map<Class<?>, UpdateHandler> handlers = new HashMap<Class<?>, Update Handler>();
Crie um método para ter os manipuladores inicializados
protected void initializeHandler() {
handler.put(Integer.class, new IntegerUpdateHandler());
handler.put(String.class, new StringUpdateHandler());
...
}
O método de atualizações simplesmente encontrará o manipulador apropriado e despachará a chamada
public void update(Observable source, Object data)
{
UpdateHandler handler = handlers.get(data.getClass()) ;
if (handler == null)
{
// use a default handler ? throw an exception ? your choice ;)
} else {
handler.update(source, data) ;
}
}
Essa implementação permitirá que você adicione um novo manipulador, conforme necessário com alterações mínimas.
Outra implementação possível pode ser feita base no trabalho anterior, apenas um procedimento de 3 etapas.
1) Altere a declaração do campo Handlers.
Map<Class<?>, Class<? extends UpdateHandler>> handlers ;
2) Altere o método de inicialização
handlers.put(Integer.class, IntegerInputHandler.class);
3) Altere o método de atualização principal para criar uma nova instância da implementação do updateHandler da Update.
UpdateHandler handlerInstance = null ;
Class<? extends UpdateHandler> handler = null ;
handler = handlers.get(data.getClass()) ;
...
handlerInstance = handler.newInstance() ;
handlerInstance.update(source, data) ;
Mova os pedaços de código dentro de cada condição para métodos nomeados adequadamente.
public void update(Observable o, Object param) {
if (o instanceof A) {
onAUpdate(o, param);
}
if (o instanceof B) {
onBUpdate(o, param);
}
}
public void onAUpdate(Observable o, Object param) {
// large chunk of code
}
public void onABUpdate(Observable o, Object param) {
// large chunk of code
}