Probleme mit Reflection

[Meru]

Hallo,

ich habe ein kleines Problem mit der Reflection API und weiß leider nicht so richtig wo dort das Problem ist.

Ich erzeuge eine Instanz von einem Interface, welches die public-Methode "showSomething(String s)" hat. Diese Instanz reiche in in eine andere Klasse wo via Reflection diese Methode ausgelöst werden soll.
Solange die 3 unten stehenden Klassen im gleichen Package sind funktioniert auch alles wunderbar. Jedoch wenn ich sie ein wenig verteilen will (also in unterschiedliche packages) kommt es zu einem Fehler und ich weiß leider nicht so genau warum.

Habt ihr da eine Idee?

package demo.blub;

public interface ITest {
	void showSomething(String s);
}

package demo.blub;

import demo.util.ReflectionClass;

public class Starter {

	public Starter() {
		ITest tester = new ITest() {
			@Override
			public void showSomething(String s) {
				System.out.println(s);
			}
		};
		ReflectionClass reflection = new ReflectionClass(tester);
	}
	
	public static void main(String[] args) {
		new Starter();
	}
}

package demo.util;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import demo.blub.ITest;

public class ReflectionClass {

	private ITest tester;
	
	public ReflectionClass(ITest tester) {
		Class c = String.class;
		
		Method targetMethod;
		try {
			targetMethod = tester.getClass().getMethod("showSomething", c);
			targetMethod.invoke(tester, new Object[]{"Hier wird etwas tolles gezeigt!!!!"});
			
		} catch (SecurityException e) {e.printStackTrace();
		} catch (NoSuchMethodException e) {e.printStackTrace();
		} catch (IllegalArgumentException e) {e.printStackTrace();
		} catch (IllegalAccessException e) {e.printStackTrace();
		} catch (InvocationTargetException e) {e.printStackTrace();}
	}
}

und erhalte folgende Fehlermeldung:
java.lang.IllegalAccessException: Class demo.util.ReflectionClass can not access a member of class demo.blub.Starter$1 with modifiers "public"
at sun.reflect.Reflection.ensureMemberAccess(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at demo.util.ReflectionClass.<init>(ReflectionClass.java:28)
at demo.blub.Starter.<init>(Starter.java:24)
at demo.blub.Starter.main(Starter.java:28)

 

[Gast2]

Du kannst/musst die Methode noch accessible setzen:

            targetMethod = tester.getClass().getMethod("showSomething", c);
            targetMethod.setAccessible(true);
            targetMethod.invoke(tester, new Object[]{"Hier wird etwas tolles gezeigt!!!!"});

 

[Meru]

Vielen dank für diesen Hinweis, damit funktioniert es bestens.

Kannst du sagen warum man das machen muss und in der anderen Varainte (alles in einem Package) nicht?

 

[SlaterB]

und das Problem ist, dass die Klasse nicht public ist

 

[Meru]

Was meinst du mit "nicht public"? Weil ich es lokal erzeugt habe?
In meinem richtigen Programm habe eine "public abstract class", welches dieses Interface implementiert (ähnlich wie MouseAdapter) und habe dort das gleiche Problem obwohl die Klasse ja ansich public ist.

Zu dem Kurzbeispiel:
Der Umkehrschluss um es public zu machen wäre dann wohl das Interface direkt zu implementieren? Zumindest hab ich das gerade mal so probiert und es funktioniert auf diese Weise.

 

[SlaterB]

wieso ist das Thema 'erledigt'?

> Der Umkehrschluss um es public zu machen wäre dann wohl das Interface direkt zu implementieren? Zumindest hab ich das gerade mal so probiert
ist dein Beispiel im ersten Posting nicht gerade 'das Interface direkt zu implementiert'?

ich habe deinen Code bei mir kopiert

public class Test
{

    public static void main(String[] args)
        throws Exception
    {
        new Starter();
    }

    public interface ITest
    {
        void showSomething(String s);
    }

    class ITest2
        implements ITest
    {

        public void showSomething(String s)
        {
            System.out.println(s);
        }
    }
}


class Starter
{

    public Starter()
        throws Exception
    {
        ITest2 tester = new Test().new ITest2();
        ReflectionClass reflection = new ReflectionClass(tester);
    }

}

+ ReflectionClass in anderem package,

so wie es jetzt steht gehts nicht, wenn in Zeile 15 das public dazu kommt, dann gehts,
'public static' geht auch, mal abgesehen davon dass Zeile 33 dann noch anzupassen ist

 

[Meru]

Hab es erst einmal auf erledigt gesetzt weil es ja mit der Lösung von EikeB funktioniert

Mit direkt implementieren meinte ich "public class Starter implements ITest".

Also dadurch wird das Object "public". Wenn ich es "Annonymous inner Type" mache (wie in meinem ersten Beispiel) ist das konkrete Objekt nicht public, obwohl mein Interface/Abstakte Klasse aber eigentlich public sind. Ich muss das Objekt also vorher auf public setzen?
Nur das kann es auch nicht sein, dann würde ja nachfolgendes auch gehen, was es aber nicht tut

package demo.blub;
 
import demo.util.ReflectionClass;
 
public class Starter {
	
	 public ITest tester = new ITest() {
		@Override
		public void showSomething(String s) {
			System.out.println(s);
		}
	 };
 
    public Starter() {
        ReflectionClass reflection = new ReflectionClass(tester);
    }
    
    public static void main(String[] args) {
        new Starter();
    }
}

 

[Wildcard]

Mit dem Objekt hat das nichts zu tun, ein Objekt kann nicht 'public' sein.
Dein Problem ist die Klasse und die ist nicht public wenn du sie anonym definierst. Die Sache mit setAccessible geht übrigens furchtbar schief wenn ein SecurityManager ins Spiel kommt, daher versucht man sowar unbedingt zu vermeiden.
Kannst du mal den Use-Case beschreiben den du mit dem Konstrukt abdecken möchtest? Es gibt fast immer eine bessere Lösung als Java Reflection...

 

[gizmo]

Ich bin auch schon über dieses Problem gestolpert...
Hier ist es erklärt: [JavaSpecialists 117] - Reflectively Calling Inner Class Methods

 

[Meru]

Ah, nu hab ichs halbwegs verstanden, vielen Dank für die Aufklärungen und Links.

Zum UseCase:
Ich habe mehrere WebServices und ein jeder solcher hat beliebig viele Funktionen unterschiedlichen Names. Um einen WebSerive anzusprechen muss man ja immer ein wenig Implementationsarbeit leisten, gerade auch wenn es im Thread ablaufen soll.

Wir haben da z.B.
WSArtikel
- getArtikelList(...);
- getArtikel(...);
- removeArtikel(...);
- ....

WSBestand
- getBestand(...)
- editBestand(...)
- ....

Meiner Implementierung (Logik-Model) soll es dabei egal sein wie das im Hintergrund gemacht wird. Hierfür brauche ich also eine
Art CallHandler zum ausführen der Services sowie auch ein Interface für die Rückgabe-Methoden, damit mein Logik-Model die Werte auch empfangen kann (Thread-Style).

Nun habe ich im CallHandler für WSArtikel ca. 20 Methoden definiert, welches dementsprechend auch 20 Rückgaben hat.

Nun war meine Überlegung folgende:
Ich will eigentlich so wenig Code wie möglich doppeln (auch wenn es generierter Code ist).
Ohne Reflection müsste jeder WebServiceAufruf im CallHandler die genaue Rückgabefunktion aus dem Interface kennen. Zudem kommt hinzu, das ein CallHandler beliebig viele "Listener" haben soll oder aber nur auf einen bestimmten Listener die Rückgabe machen (wenn ein konkreter Listener übergeben wird)

Bsp (Pseudecode)

public void callService_getArtikel(ArtikelQuery query, IArtikelResponse response){
	CallObject co = new CallObject(){
		Artikel r;
		public String getOperationName() {return "getArtikel";}

		public void call(){
			// führe call aus (r = webserive.getArtikel)
		}
		public void success(){
 			if (response == null){
				for (int i=0; i < listenerList.size(); i++){
					listener.get(i).artikelResponse(r);
				}
			}else{
				response.artikelResponse(r);
			}
		}
		public void failure(Exception e){
			if (response == null){
				for (int i=0; i < listenerList.size(); i++){
					listener.get(i).failure(e, getOperationName();
				}
			}else{
				response.failure(e, getOperationName();
			}
	wscaller.call(co);
	}
}

Mir geht es dabei um die "success"- und die "failure"-Methode.
Ich habe insgesamt 20 Services zu je 5-20 Methoden. Das ist halt eine sehr häufige CodeVerdoppelung.
Daher wollte ich über Reflection gehen und sagen:

	public void success() {
		WSArtikelCallHandler.this.serviceAuswertung(getOperationName(), result, responseObject);
	}
	public void failure(Exception e) {
		WSArtikelCallHandler.this.failure(e, getOperationName(), responseObject);
	}

Somit wäre es dann deutlich schlanker vom Cellcode her und auch keine Doppelung.


Mir will da nicht richtig einfallen, wie ich es anders machen kann ohne diese CodeDoppelung. Aber da es generiert ist, kann es mir eigentlich egal sein. Diese Klassen soll ja eh keiner anfassen und kann bei Bedarf ja auch anders Implementiert werden. Genau deswegen will ich es ja von meinem Model trennen, falls sich die Schnittstelle zum Server mal irgendwann ändern sollte.

 

[Wildcard]

Deine Beschreibung habe ich um ehrlich zu sein nur bedingt verstanden (obwohl sie ja recht ausführlich war). Von dem was ich verstanden habe, scheint mir das Command Pattern allerdings ein geeigneter Ersatz zu sein (und anders als bei Reflection verlierst du die Compile Time Sicherheit nicht).
Command Pattern | Object Oriented Design