使用反射从扩展实例获取特定属性

Question

我想做一个通用的方法来从参数对象中获得一个列表。

问题在于我有一个声明的对象，该对象具有扩展该声明类的另一个类的实例。我不想使用instanceof解决方案，因为扩展LimitedValue的类的数量可能很大。

我想使用反射的解决方案，但我不知道如何使用对象的实例，在这部分代码:

    Class cls = Class.forName(limitedValue.getClass().getName());
    Object obj = cls.newInstance();
    //This is wrong, I don't want a new instance.
    Method[] methods = cls.getDeclaredMethods();
    for(int x= 0; x < methods.length; x++) {
        Method method = methods[x];
        if ("java.util.List".equals(method.getReturnType().getName())) {
            //How to get the value of this method from limitedValue instance ?
        }
    }

这是我的完整代码:

public class CalculatorLimitedValue {
    public static void main(String[] args) throws Exception {
        StoreItem storeItem = new StoreItem(1L, "Name of StoreItem", 50L);
        List listOfStoreItems = new ArrayList();
        listOfStoreItems.add(storeItem);
        LimitedValue limitedValue0 = new Store(listOfStoreItems);
        List firstList = calculator(limitedValue0);
        //do something with the list
        SupermarketItem supermarketItem = new SupermarketItem(1L, "Name of SupermarketItem", 21L);
        List listOfSupermarketItems = new ArrayList();
        listOfSupermarketItems.add(supermarketItem);
        LimitedValue limitedValue1 = new Supermarket(listOfSupermarketItems);
        List secondList = calculator(limitedValue1);
        //do something with the list
    }
    /** This is the method that I'd like to make generic to return a List */
    private static List calculator(LimitedValue limitedValue) throws Exception{
        Class cls = Class.forName(limitedValue.getClass().getName());
        Object obj = cls.newInstance();
        //This is wrong, I don't want a new instance.
        Method[] methods = cls.getDeclaredMethods();
        for(int x= 0; x < methods.length; x++) {
            Method method = methods[x];
            if ("java.util.List".equals(method.getReturnType().getName())) {
                //How to get the value of this method from limitedValue instance ?
            }
        }
        /* I don't want to use this one way, because my classes that extends LimitedValue 
        can be big. I would like to made a generic way to get de list of classes. */
        if (limitedValue instanceof Store) {
            System.out.println("This is a store");
            return ((Store) limitedValue).getStoreItems();
        } else if (limitedValue instanceof Supermarket) {
            System.out.println("This is a supermarket");
            return ((Supermarket) limitedValue).getSupermarketItems();
        }
        return null;
    }
}

如果它有帮助，这些是我的其他类:

LimitedValue.class

public class LimitedValue { }

StoreItem.class

public class StoreItem {
    private Long id;
    private String nameOfStoreItem;
    private Long valueOfStoreItem;
    public StoreItem(Long id, String nameOfStoreItem, Long valueOfStoreItem){ 
        this.id = id;
        this.nameOfStoreItem = nameOfStoreItem;
        this.valueOfStoreItem = valueOfStoreItem;
    }
//getters and setters...
}

SupermarketItem.class

public class SupermarketItem {
    private Long id;
    private String nameOfSupermarketItem;
    private Long valueOfSupermarketItem;
    public SupermarketItem() {
    }
    public SupermarketItem(Long id, String nameOfSupermarketItem, Long valueOfSupermarketItem) {
        this.id = id;
        this.nameOfSupermarketItem = nameOfSupermarketItem;
        this.valueOfSupermarketItem = valueOfSupermarketItem;
    }
//getters and setters...
}

Store.class

public class Store extends LimitedValue {
    private List<StoreItem> storeItems;
    public Store(List<StoreItem> storeItems) {
        this.storeItems = storeItems;
    }
    //getters and setters
}

Supermarket.class

public class Supermarket extends LimitedValue {
    private List<SupermarketItem> supermarketItems;
    public Supermarket(List<SupermarketItem> supermarketItems) {
        this.supermarketItems = supermarketItems;
    }
    //getters and setters
}

Answer 1

您可以尝试在这里使用反射来尝试实现您想要的，但是最好重新考虑您的整体设计，并尝试使用更好的面向对象设计来解决手头的问题。

特别地，假设我们考虑向LimitedValue类添加一个名为getItems的方法，该方法返回一个项目列表，该列表可能是SupermarketItem s或StoreItem s。如果它的结构正确，您将不需要知道实际类型，因为代码将以多态形式在其上抽象。

public abstract class LimitedValue {    
  List<? extends Item> getItems();
}

我们现在已经在LimitedValue上定义了一个新方法，但我们也必须考虑到我们已经引入了这个新的Item。我注意到SupermarketItem和StoreItem都具有相似的属性，name, id和value，因此似乎可以使用单个类来表示它们。

public abstract class Item {
  final Long id;
  final String name;
  final Long value;
  public Item(final Long id, final Long name, final Long value) {
    this.id = id;
    this.name = name;
    this.value = value;
  }
  String getName() {
    return name;
  }
  // other getters and setters
}
public class SupermarketItem extends Item {
  public SupermarketItem(final Long id, final Long name, final Long value) {
    super(id, name, value);
  }
}
public class StoreItem extends Item {
  public StoreItem(final Long id, final Long name, final Long value) {
    super(id, name, value);
  }
}

现在我们已经完全抽象了访问这些对象时对任何反射的需要——你可以简单地调用item. getvalue()，因为你知道列表中的每个项目都是item类型的。

当然，还需要重构Store和SuperMarket类，例如:

public class Supermarket extends LimitedValue {
    private List<SupermarketItem> supermarketItems;
    public Supermarket(List<SupermarketItem> supermarketItems) {
        this.supermarketItems = supermarketItems;
    }
    public List<? extends Item> getItems() {
      return supermarketItems;
    }
}

，因为你只返回一个List<Item>，你总是知道里面是什么，你可以改变你的主代码来工作。

Answer 2

要获取List值，请使用Method#invoke:

List list = method.invoke(limitedValue);

你不需要Object obj = cls.newInstance(); -你根本没有在方法中使用它。

无论如何，你是在给自己制造困难。你也可以定义一个接口

public interface HasList<E> {
    List<E> getList();
}

并让所有类实现这个