JComponent<-----Eigenschaften<-- Als Liste abfragen?

[JFeel-x]

Hallo an alle,
kann man alle Eigenschaften eines JComponent auf einmal(am besten in einen JTable passend)abfragen oder muss/sollte man besser jede Eigenschaft für sich abfragen?

Ich möchte alle auflisten, ungefähr so wie die Property-Sicht bei NetBeans, und sie per tabelleneintrag bearbeiten können.

Vielen Dank im Vorraus

 

[SlaterB]

vielleicht ist Reflection was für dich,
da kannst du dir alle internen Datenfelder als Liste geben lassen und diese dann mit wenig Aufwand durchlaufen

hat aber wenig mit normalen Programmieren zu tun

 

[JFeel-x]

Danke für die schnelle Antwort,
ich habe mir Reflection nun zum ersten mal angesehen.

Die Methode "getFields()" ist mir dabei direkt ins Auge gefallen.

Als ich den folgenden Code ausgeführt habe, habe ich ausschließlich die Swing u. Awt-Konstanten bekommen, ich würde gern auf beispielsweise die Farbe, Location, etc. zugreifen(ansehen, ändern kann ich sie ja auch ohne reflection)...

Hier mein bisheriger Code:

import java.lang.reflect.Field;

import javax.swing.JComponent;
import javax.swing.JLabel;

public class Properties{

JComponent component;

Field[] properties;

public Properties(JComponent component)
{

 if( component==null  )throw new IllegalArgumentException("The Component mustn't be null!!");
	 
 this.component = component; 
 
 properties = component.getClass().getFields();

 for(int i=0;i < properties.length;i++)
 System.out.println(properties[i]);

}
public static void main(String[]args){
	JLabel l = new JLabel("Moep");
	l.setLocation(3,5);
	new Properties(l);
}
}

 

[SlaterB]

tja, in 5 Min. kann man ja nicht alles hinbekommen, nächstes Mal etwas länger schauen,

mir scheint nach selbigen kurzem Nachschauen, dass man immer nur die Felder einer Klasse abfragen kann, nicht die von der Oberklasse gleichzeitig auch,
da musst du das dann so machen wie folgt (+ weitere Oberklassen) oder selber weitersuchen oder jemand anders schreibt noch mehr:

public class Test
{
    JComponent component;

    Field[] properties;

    public Test(JComponent component)
        throws Exception
    {

        if (component == null) throw new IllegalArgumentException("The Component mustn't be null!!");

        this.component = component;

        properties = component.getClass().getDeclaredFields();

        for (int i = 0; i < properties.length; i++)
        {
            Field f = properties[i];
            if (Modifier.isStatic(f.getModifiers()))
            {
                continue;
            }
            f.setAccessible(true);
            System.out.println(f + ": " + f.get(component));
        }

        properties = Component.class.getDeclaredFields();
        System.out.println("\n");
        for (int i = 0; i < properties.length; i++)
        {
            Field f = properties[i];
            if (Modifier.isStatic(f.getModifiers()))
            {
                continue;
            }
            f.setAccessible(true);
            System.out.println(f + ": " + f.get(component));
        }

    }

    public static void main(String[] args)
        throws Exception
    {
        JLabel l = new JLabel("Moep");
        l.setLocation(3, 5);
        new Test(l);
    }
}

 

[Murray]

getFields liefert durchaus auch die Fields der Oberklassen mit; allerdings eben nur solche, die als public markiert sind. Um auch andere Fields zu bekommen, muss man in der Tat über getDeclaredFields gehen und dabei dann eben - wie von Slater vorgeschlagen - die Superklassen mit einbeziehen.

Möglicherweise ist aber auch das noch nicht zielführend: es besteht duchaus die Möglichkeit, dass es für manche "Eigenschaften" überhaupt keine direkten Member gibt, sondern dass es lediglich set- und getMethoden gibt. Falls man auch solchen "Properties" einbeziehen will, dann muss man über get(Declared)Methods gehen und sich die passenden Getter-Setter-Paare heraussuchen

 

[Murray]

Das Beipsiel entsprechend erweitert:

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashMap;

import javax.swing.JComponent;
import javax.swing.JLabel;

public class Test
{
    JComponent component;
    final HashMap<String,Object> props = new HashMap<String,Object>();
    
    public Test(JComponent component)
        throws Exception
    {

        if (component == null) throw new IllegalArgumentException("The Component mustn't be null!!");

        this.component = component;
        
        iterateProperties( props, component);

    }
    
    public HashMap<String,Object> getProperties() {
    	return props;
    }

    private static void iterateProperties( final HashMap<String,Object> props, final Object instance)  {
    	iterateFields(  props, instance.getClass(), instance);
    	iterateMethods( props, instance.getClass(), instance);

    }

    private static void iterateFields( final HashMap<String,Object> props, final Class cls, final Object instance)  {
    
    	if ( cls == null) return;
    	
        Field[] flds = cls.getDeclaredFields();

        for (Field f: flds) {
            if ( Modifier.isStatic(f.getModifiers())) continue;
            try {
            	f.setAccessible( true); 
	            props.put( f.getName(), f.get( instance));
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
         }
        iterateFields( props, cls.getSuperclass(), instance);
    }

    private static void iterateMethods( final HashMap<String,Object> props, final Class cls, final Object instance)  {
    
    	if ( cls == null) return;
    	
        Method[] mthds = cls.getDeclaredMethods();

        for (Method m : mthds) {
            if ( Modifier.isStatic(m.getModifiers())) continue;

            if ( m.getReturnType() == null) continue; //--- skip void methods
            if ( m.getParameterTypes().length > 0) continue; //--- skip methods that required parameters

            String mn = m.getName();
            if ( mn.startsWith( "get") || (mn.startsWith( "has"))) {
            	mn = mn.substring( 3);
            } else if ( mn.startsWith( "is")) {
            	mn = mn.substring( 2);
            } else {
            	continue;
            }
            if ( mn.length() == 0) continue;
            
            if ( !Character.isUpperCase( mn.charAt(0))) continue; 
            
            if ( props.containsKey( mn)) continue; //--- skip getter if a field with the same name already exists
            	         
            try {
            	m.setAccessible( true);             	
	            props.put( mn, m.invoke( instance, new Object[0]));	            
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.printStackTrace();
			}
         }
        iterateMethods( props, cls.getSuperclass(), instance);
    }

    public static void main(String[] args) throws Exception {
        JLabel l = new JLabel("Moep");
        l.setLocation(3, 5);

        HashMap<String,Object> props = new Test(l).getProperties();
        for ( String key : props.keySet()) {
        	System.out.println( key + " : " + props.get( key));
        }
    }
}

 

[JFeel-x]

Vielen Dank, nächstes mal schau ich genauer hin , das reicht völlig für meine Zwecke.

Eine Frage hätte ich aber noch: wenn ich das richtig verstanden habe, kann man ja theoretisch mit reflection alles ändern/lesen, wenn man es per setAccessible zugänglich macht :?: :!: :shock:

 

[SlaterB]

zu der Frage passt ja nur
http://www.javaspecialists.eu/archive/Issue014.html

 

[Murray]

wenn ich das richtig verstanden habe, kann man ja theoretisch mit reflection alles ändern/lesen, wenn man es per setAccessible zugänglich macht :?: :!: :shock:

Grundsätzlich kann man so die "normalen" Zugriffsbeschränkungen aushebeln; allerdings kann ein SucurityManager diese Möglichkeiten beschränken.