Benachrichtigung bei neuer Objekt-Instanz

[sambalmueslie]

Hallo,

ich bin im Zuge von EJB auf Annotations als gestoßen um Klassen zu Dekorieren.
Jetzt bin ich gerade etwas am Forschen wie so etwas gehen könnte da Annotations ja nur Meta-Informationen enthalten.

Mein Ansatz ist, dass ich an einer geeigneten Stelle "überwache" ob eine neue Instanz zu einer Klasse gehört die eine bestimmte Annotation enthält.

Meine Frage ist jetzt, gibt es diese geeignete Stelle und wo ist die?
Habe zunächst an den Classloader gedacht aber der springt ja nur zu Beginn an (zumindest verstehe ich das so), wenn die Klasse zum ersten mal geladen wird und das würde mir nichts bringen.

Hat jemand da ein paar Infos die mir weiterhelfen könnten Reicht auch nur ein Begriff nachdem ich googlen darf

Gruß Oli

 

[Tomate_Salat]

Annotationen sind lustig, damit spiele ich in letzter Zeit auch gerne rum. Aber hier würde sich wohl eher Vererbung anbieten:

import java.util.ListIterator;
import java.util.Vector;

public class InstWatcher
{
	public static void main(String[] args) 
	{
		ICreationListener myListener=new ICreationListener() {
			@Override
			public void objectCreated(TObject object) {
				System.out.println("Ein neues Objekt wurder erstellt");
			}
		};
		
		TObject.addCreationListener(myListener);
		
		new MyObject();
	}
}

interface ICreationListener
{
	void objectCreated(TObject object);
}

class TObject
{
	private static Vector<ICreationListener> listener=new Vector<ICreationListener>();
	
	public TObject() 
	{
		for(ListIterator<ICreationListener> it=listener.listIterator();it.hasNext();)
			it.next().objectCreated(this);
	}
	
	public static void addCreationListener(ICreationListener listener)
	{
		TObject.listener.add(listener);
	}
	
	public static void removeCreationListener(ICreationListener listener)
	{
		TObject.listener.remove(listener);
	}
}

class MyObject 
	extends TObject
{
	public void doSomething()
	{
		System.out.println("MyObject.doSomething()");
	}
}

über Annotationen wüsste ich auf die schnelle keinen Weg das zu überwachen. Zumal diese Ausgwertet werden müssten, d.h du hättest dann in etwa sowas:

import static de.my.package.SomeClass.NEW;
....
MyObject obj=NEW(MyObject.class);

allerdings bräuchtest du dann auch keine Annotationen ;-)

 

[sambalmueslie]

Hm das mit Vererbung geht natürlich, wobei ich dann keine Überwachung brauche sondern lediglich eine ServiceFacade für meine Dienste zur Verfügung stelle.

public interface ServiceFacade {

... here are the services :-) 

}

public abstract class ServiceProvider {

public ServiceFacade getServices(){
return facade;
}

}


public class MyHandler extends ServiceProvider {


handle the stuff

}

aber genau das möchte ich nicht sondern ich stelle mir das so hier vor:

public class MyHandler {

@Service
private ServiceFacade services;

}

und via Reflection wird die ServiceFacade gesetzt its magic und its transparent


Gruß Oli

 

[Tomate_Salat]

Willkommen in der Welt von Dependency Injection ;-) : GUICE
----
Randnotiz: Wenn es dir um die Technik geht, wie man mit Annotationen arbeitet/arbeiten kann. In meinem Block findest du diverse Beispiele (der Source liegt immer dabei).

 

[sambalmueslie]

jao der SpringSource.org | oder EJB ..

aber wie geht das?? ich will mich da mal selber austoben ohne jetzt ein neues Spring erfinden zu wollen

 

[Tomate_Salat]

Ein Beispiel auf die schnelle:

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class InstWatcher
{
	@Service private String simpleDemo;
	
	public static void main(String[] args) throws Exception 
	{
		InstWatcher w=Factory.getInstance(InstWatcher.class);
		System.out.println(w.getSimpleDemo());
	}
	
	public String getSimpleDemo()
	{
		return simpleDemo;
	}
}

class Factory
{
	private Factory() {}
	
	public static <T> T getInstance(Class<T> cl) throws Exception
	{
		Constructor c=cl.getDeclaredConstructor();
		c.setAccessible(true);
		T inst=(T) c.newInstance();
		
		for(Field f:cl.getDeclaredFields()) {
			if(f.isAnnotationPresent(Service.class)) {				
				f.setAccessible(true);
				f.set(inst, "Hallo Welt");
			}
		}
		
		return inst;
	}
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface Service {}

Du musst dich da halt reinarbeiten. Schau dir GUICE an, da habe ich nette Ideen her, wie man was über Annotationen lösen kann. Wichtig ist bei der Erstellung einer Annotation, die Annotation: [c]@Retention(RetentionPolicy.RUNTIME)[/c], sonst kannst du diese zur Laufzeit nicht auswerten.