Java reflection-access protected field

Użyj reflection, aby uzyskać dostęp do członków instancji klasy, uczynić je dostępnymi i ustawić ich odpowiednie wartości. Oczywiście musisz znać nazwisko każdego członka, którego chcesz zmienić, ale myślę, że nie będzie to problemem.

public class ReflectionUtil {
    public static Field getField(Class clazz, String fieldName) throws NoSuchFieldException {
        try {
            return clazz.getDeclaredField(fieldName);
        } catch (NoSuchFieldException e) {
            Class superClass = clazz.getSuperclass();
            if (superClass == null) {
                throw e;
            } else {
                return getField(superClass, fieldName);
            }
        }
    }
    public static void makeAccessible(Field field) {
        if (!Modifier.isPublic(field.getModifiers()) ||
            !Modifier.isPublic(field.getDeclaringClass().getModifiers()))
        {
            field.setAccessible(true);
        }
    }
}

public class Application {
    public static void main(String[] args) throws Exception {
        KalaGameState obj = new KalaGameState();
        Field field = ReflectionUtil.getField(obj.getClass(), 'turn');
        ReflectionUtil.makeAccessible(field);
        field.setInt(obj, 666);
        System.out.println("turn is " + field.get(obj));
    }
}

field = myclass.getDeclaredField("myname");
field.setAccessible(true);
field.set(myinstance, newvalue);

Użyj FieldUtils.writeField(object, "fieldname", value, true) LUB readField(object, "fieldname", true) z Apache Commons lang3 .

Nie chciałem ciągnąć więcej bibliotek, więc zrobiłem czystą bibliotekę, która działała dla mnie. Jest to rozszerzenie jednej z metod jweyricha:

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Date;
import java.util.Random;
import java.util.UUID;

public abstract class POJOFiller {

    static final Random random = new Random();

    public static void fillObject(Object ob) {
        Class<? extends Object> clazz = ob.getClass();

        do {
            Field[] fields = clazz.getDeclaredFields();
            fillForFields(ob, fields);

            if (clazz.getSuperclass() == null) {
                return;
            }
            clazz = clazz.getSuperclass();

        } while (true);

    }

    private static void fillForFields(Object ob, Field[] fields) {
        for (Field field : fields) {
            field.setAccessible(true);

            if(Modifier.isFinal(field.getModifiers())) {
                continue;
            }

            try {
                field.set(ob, generateRandomValue(field.getType()));
            } catch (IllegalArgumentException | IllegalAccessException e) {
                throw new IllegalStateException(e);
            }
        }
    }

    static Object generateRandomValue(Class<?> fieldType) {
        if (fieldType.equals(String.class)) {
            return UUID.randomUUID().toString();
        } else if (Date.class.isAssignableFrom(fieldType)) {
            return new Date(System.currentTimeMillis());
        } else if (Number.class.isAssignableFrom(fieldType)) {
            return random.nextInt(Byte.MAX_VALUE) + 1;
        } else if (fieldType.equals(Integer.TYPE)) {
            return random.nextInt();
        } else if (fieldType.equals(Long.TYPE)) {
            return random.nextInt();
        } else if (Enum.class.isAssignableFrom(fieldType)) {
            Object[] enumValues = fieldType.getEnumConstants();
            return enumValues[random.nextInt(enumValues.length)];
        } else if(fieldType.equals(Integer[].class)) {
            return new Integer[] {random.nextInt(), random.nextInt()};
        }
        else {
            throw new IllegalArgumentException("Cannot generate for " + fieldType);
        }
    }

}

Jeśli dopiero otrzymujesz chronione pole

Field protectedfield = Myclazz.class.getSuperclass().getDeclaredField("num");

Jeśli używasz Eclipse Ctrl + Spacja wyświetli listę metod po wpisaniu "."po obiekcie

Jeśli używasz sprężyny, Reflectestutils zapewnia kilka przydatnych narzędzi, które pomagają tutaj przy minimalnym wysiłku.

Na przykład, aby uzyskać wartość pola chronionego, która jest znana jako int:

int theIntValue = (int)ReflectionTestUtils.getField(theClass, "theProtectedIntField");

Lub alternatywnie ustawić wartość tego pola:

ReflectionTestUtils.setField(theClass, "theProtectedIntField", theIntValue);

Czy może masz na myśli z innego obiektu niezaufany kontekst z SecurityManager zbiorem? To złamałoby system typów, więc nie możesz. z zaufanego kontekstu możesz wywołać setAccessible, aby pokonać system typów. Najlepiej nie używać odbicia.

Mógłbyś zrobić coś takiego...

Class clazz = Class.forName("SuperclassObject");

Field fields[] = clazz.getDeclaredFields();

for (Field field : fields) {
    if (field.getName().equals("fieldImLookingFor")) {
        field.set...() // ... should be the type, eg. setDouble(12.34);
    }
}

Może być również konieczna zmiana dostępności, jak zaznaczono w odpowiedzi Maurice ' a.

Generic utility method to run any getter in this or any superclass.

Zaadaptowana z odpowiedzi Mariusa.

public static Object RunGetter(String fieldname, Object o){
    Object result = null;
    boolean found = false;
    //Search this and all superclasses:
    for (Class<?> clas = o.getClass(); clas != null; clas = clas.getSuperclass()){
        if(found){
           break;
        }
        //Find the correct method:
        for (Method method : clas.getDeclaredMethods()){
            if(found){
                break;
            }
            //Method found:
            if ((method.getName().startsWith("get")) && (method.getName().length() == (fieldname.length() + 3))){ 
                if (method.getName().toLowerCase().endsWith(fieldname.toLowerCase())){                            
                    try{
                        result = method.invoke(o);  //Invoke Getter:
                        found = true;
                    } catch (IllegalAccessException | InvocationTargetException ex){
                        Logger.getLogger("").log(Level.SEVERE, "Could not determine method: " + method.getName(), ex);
                    }
                }
            }
        }
    }
    return result;
}