# Variablen auf Änderungen hin überwachen?



## ellion (19. Dezember 2005)

Hallo Forum.

Ich habe eine Klasse "Examination", die kaum mehr tut als Daten, die aus einer Datenbank gelesen werden bereitzustellen. 
Jetzt würde ich es aber gerne so haben, dass, sobald eine Eigenschaft dieser Klasse verändert wird, die Daten mit der DB synchronisiert werden. Anders gesagt: Bei Wertänderung soll eine Funktion aufgerufen werden.

Der PropertyChangeListener funktioniert zwar, ruft die Funktion aber öfters auf, als ich brauche. Praktischerweise würde ich gerne nur 2, 3 Variablen auf Änderung überprüfen.

Muss ich einen eigenen Listener schreiben oder gibt es bereits vergleichbare?


Danke im Vorraus,
Daniel


----------



## schnuffie (19. Dezember 2005)

Ja, ich glaube auch, daß der PropertyChangeListener nur auf die gesamte Bean, argo auf alle Properties angewendet werden kann. Willst Du nur einzelne Variablen kontrollieren, kommst Du sicherlich mit einem eigenen Listener gut vorwärts oder prüfst im PropertyChangeListener einfach ab, ob es eine solche Variable war, die geändert wurde.

Ich löse solche Aufgaben immer gern mit TransferObjects (also auch Beans), in denen ich die Parameter setzen und auslesen kann, wie ich will und mittels Update-Methode wird der ganze Inhalt dann wieder in die DB geschrieben. Natürlich hat das den Nachteil, daß ein nachträgliches Auslesen während der Bearbeitung noch alte Werte beinhaltet. Mit einem Locking-Mechanismus kannst Du das allerdings auch recht schön unterbinden.


----------



## Thomas Darimont (19. Dezember 2005)

Hallo!

 Wenn du deine Java Klassen nicht aendern moechtest koenntest du das auch mit Dynamic Proxies machen. Entweder du nimmst dann JDK Dynamic Proxies (dann muessen deine Java Klassen die entsprechenden Methoden ueber ein Interface deklarieren) oder du verwendest CGLib Proxies... damit kannst du dynamic Proxies auch aus ganz normalen java Klassen basteln:

```
/**
    * 
    */
   package de.tutorials;
   
   import java.lang.reflect.Method;
   
   import net.sf.cglib.proxy.Enhancer;
   import net.sf.cglib.proxy.MethodInterceptor;
   import net.sf.cglib.proxy.MethodProxy;
   
   /**
    * @author tom
    * 
    */
   public class ObjectChangeMonitorExample {
   
   	/**
   	 * @param args
   	 */
   	public static void main(String[] args) {
   		Enhancer enhancer = new Enhancer();
   		enhancer.setSuperclass(SomeObject.class);
   		enhancer.setCallback(new MethodInterceptor() {
   			public Object intercept(Object target, Method method,
 				 Object[] args, MethodProxy proxy) throws Throwable {
 		     //Hier mal eine sehr naive Implementierung...
   			    if (method.getName().startsWith("set")) {
 				 if (method.getName().toUpperCase().indexOf("SOMEVALUE") > 0) {
 					 System.out
 							 .println("someValue is about to be changed! old value-> "
 									 + ((SomeObject) target).getSomeValue()
 									 + " new value->" + args[0]);
   					}
   				}
   			    return proxy.invokeSuper(target, args);
   			}
   		});
   
   		SomeObject someObject = (SomeObject) enhancer
 			 .create(new Class[] { String.class, String.class },
 					 new Object[] { "Hallo", "Welt!" });
   		
   		System.out.println(someObject);
   		
   		someObject.setSomeValue("foo");
   		someObject.setSomeOtherValue("bar");
   		
   		System.out.println(someObject);
   
   	}
   
   	static class SomeObject {
   		private String someValue;
   
   		private String someOtherValue;
   
   		public SomeObject() {
   			this(null, null);
   		}
   
   		public SomeObject(String someValue, String someOtherValue) {
   			this.someValue = someValue;
   			this.someOtherValue = someOtherValue;
   		}
   
   		public void setSomeOtherValue(String someOtherValue) {
   			this.someOtherValue = someOtherValue;
   		}
   
   		public void setSomeValue(String someValue) {
   			this.someValue = someValue;
   		}
   
   		public String getSomeOtherValue() {
   			return someOtherValue;
   		}
   
   		public String getSomeValue() {
   			return someValue;
   		}
   
   		public String toString() {
   			return super.toString() + "(" + this.someValue + ", "
  				 + this.someOtherValue + ")";
   		}
   	}
   }
```
 
   Ausgabe:

```
de.tutorials.ObjectChangeMonitorExample$SomeObject$$EnhancerByCGLIB$$adcd9e1@2808b3(Hallo, Welt!)
   some value is updated: old value-> Hallo new value->foo
   de.tutorials.ObjectChangeMonitorExample$SomeObject$$EnhancerByCGLIB$$adcd9e1@2808b3(foo, bar)
```
 
   Gruss Tom


----------

