fehlende Mehrfachvererbung logging.Handler impl. Observable

[Puste]

Hallo allerseits.

Stehe vor folgendem Problem,
ich implementiere einen logging.Handler, an welchem sich Observer anmelden können müssen.
Jedoch weder logging.Handler, noch Observable bietet mir ein Interface, um die fehlende Mehrfachvererbung zu umgehen. Einfach ausgedrückt, zwei Mutterklassen, Handler und Observable, wie vereine ich diese.


Meine beiden Ansätze bisher:

Variante A:
Man implementiert die Methoden der Klasse Observable in der eigenen Handler Klasse.
Dummerweise scheitert es dann an:

void notifyObservers(Object obj) {
		for (Observer o : observers) {
			o.update(this, obj);
		}
	}

Ich kann die eigene Handlerinstanz nicht an die Observer weiterreichen, weil sie nicht vom Typ Observable ist.

Variante B:
Ich erzeuge ein Feld Observable in meiner Handler Klasse auf welches ich dann von außen zugreifen kann.
Auch hier scheitert es dann an der setChanged() Methode des Observers, ... protected, ich kann von meiner Handler Klasse nicht auf drauf zugreifen.


Eine eigene implementation des Observer Patterns würde ich gerne erstmal umgehen, existieren zu solch einer Design-Problematik schon Lösungsansätze? Irgendwie habe ich bisher zu wenig mit den java eigenen Observern gearbeitet.

 

[Spacerat]

Was soll das an sich werden? Soll der Handler etwa gleichzeitig Observer und Oservable sein? Dann müssen auch beide "Interfaces" implementiert werden. Z.B. Kann man dem innerhalb des Handlers Observable anonym implementieren und dessen Methoden in die Handlerklasse einbauen. Ich glaube das Pattern dazu heist "Method-Delegate".

mfg Spacerat

 

[Puste]

"Was soll das an sich werden?"

Folgendes wäre optimal:

public class MyHandler extends java.util.logging.Handler implements java.util.Observable

funktioniert nur leider nicht, da Observable eine Klasse ist.


Das Delegate Pattern würde auf das gleiche Problem wie Variante A hinauslaufen. Ich habe in meiner Klasse zwar alle Methoden von Observable, bin aber nicht im stande ein update(this, obj); aufzurufen, weil this nicht vom Typ Observable ist.
Ebenso würde Delegate auch das Problem aus Variante B hervorbringen, ich kann nicht auf die setChanged() und clearChanged() Methoden der Observable Instanz zugreifen, weil diese nicht public sind.

 

[Spacerat]

Gut... Misverständnis... "Interface" stand ja auch in Anführungszeichen da.
Ich meine das so...

import java.util.Observable;
import java.util.Observer;
import java.util.logging.Handler;
import java.util.logging.LogRecord;

public class TestHandler
extends Handler
implements Observer
{
    private final MyObservable obs = new MyObservable();

    public void close() throws SecurityException
    {
    }

    public void flush()
    {
    }

    public void publish(LogRecord record)
    {
    }

    public void update(Object arg)
    {
        update(obs, arg);
    }

    public void update(Observable o, Object arg)
    {
        // Variante B:
    }

    public void addObserver(Observer o)
    {
        obs.addObserver(o);
    }

    public void clearChanged()
    {
        obs.clearChanged();
    }

    public int countObservers()
    {
        return obs.countObservers();
    }

    public void deleteObserver(Observer o)
    {
        obs.deleteObserver(o);
    }

    public void deleteObservers()
    {
        obs.deleteObservers();
    }

    public boolean hasChanged()
    {
        return obs.hasChanged();
    }

    public void notifyObservers(Object o)
    {
        obs.notifyObservers(o);
    }

    public void notifyObservers()
    {
        obs.notifyObservers();
    }

    public void setChanged()
    {
        obs.setChanged();
    }

    private static final class MyObservable
    extends Observable
    {
        public synchronized void clearChanged()
        {
            super.clearChanged();
        }

        public synchronized void setChanged()
        {
            super.setChanged();
        }
    }
}

Leider habe ich keinen Code für deine Variante B. Der Wermutstropfen der bleibt, ist, dass die geforderte Methode "update(Observable obs, Object obj)" relativ überflüssig ist, da das verwendete Observable ja nach aussen hin nicht sichtbar ist.

mfg Spacerat

 

[Puste]

Ja, an einem ähnlichen Punkt war ich auch, nur das es langsam Sinn ergibt.

Bin jetzt bei diesem code angelangt:

public class RingBufferHandler2 extends Handler {
	private RingBuffer<LogRecord> buffer;
	private ObservableImpl observable = new ObservableImpl();
	
            [...]

	@Override
	public void publish(LogRecord record) {
		if (!isLoggable(record))
			return;

		synchronized(this) {
			buffer.push(record);
			observable.setChanged();
			observable.notifyObservers(record);
			observable.clearChanged();
		}
	}
	
	public Observable getObservable() {
		return observable;
	}
	
	private final class ObservableImpl extends Observable {

		public void setChanged() {
			super.setChanged();
		}
		
		public void clearChanged() {
			super.clearChanged();
		}
		
	}
}

Sieht ja garnicht schlecht aus, könnte man sogar ein Interface für machen :autsch:
Irgendaws stört mich noch daran, aber zumindest spare ich mir 3 Klassen in der Lib.

Dank Dir

 

[Spacerat]

Was störend sein könnte, ist die Tatsache das deine "ObservableImpl" nicht statisch ist. Für meine Lösung hatte ich noch im Sinn "obs" ebenfalls statisch zu machen. Dann gibt es nur ein "Observable" in welchem alle Handler registriert werden.

mfg Spacerat