从另一种方法动态初始化一个POJO

Question

假设我有这些POJO类实现一个接口，但这里没有共同的属性。

public interface MainIfc {} 

class Ifc1 implements MainIfc { 
    private String a1; 
    public String getA1() { 
     return a1; 
    } 
    public void setA1(String a1) { 
     this.a1 = a1; 
    } 
} 

class Ifc2 implements MainIfc { 
    private String x1; 
    private String x2; 
    public String getX1() { 
     return x1; 
    } 
    public void setX1(String x1) { 
     this.x1 = x1; 
    } 
    public String getX2() { 
     return x2; 
    } 
    public void setX2(String x2) { 
     this.x2 = x2; 
    } 
} 

而在这些POJO类我有几个，我可以用它来获取POJO的类型方法一起返回基于另一个值和值实际POJO。

public class GetIfc { 
    public Class getIfcType(int code) { 
     if (code==1) 
      return Ifc1.class; 
     else 
      return Ifc2.class; 
    } 
    public MainIfc getIfc(int code) { 
     if (code==1) { 
      Ifc1 thisIfc = new Ifc1(); 
      thisIfc.setA1("Ifc1"); 
      return thisIfc; 
     } else { 
      Ifc2 thisIfc = new Ifc2(); 
      thisIfc.setX1("Ifc2"); 
      thisIfc.setX2("Ifc2"); 
      return thisIfc; 
     } 
    } 
} 

是否有使用，我可以在我的代码安全地读混凝土POJO和使用getter/setter方法的方法吗？我经历了很多提供基于反思的答案的问题，但这不适合我。当我打电话时，getter/setter不可见。 getClass()关于返回的对象我看到它是MainIfc接口。

我试图解决的设计问题属于我试图设计的REST API自动化框架。基本上我有一个ClientResponse解析器，它将发回我正在寻找的POJO。但我不想让编写测试用例的人担心返回的POJO类型。所以我想我可以返回类型和实例化的POJO，所以我得到的值，但我很困扰如何动态实现这一点。

Answer 1

MainIfc的消费者实际上是否需要POJO，或者只是其中的数据？

如果MainIfc声明了一个或两个暴露消费者需要的数据的方法，它可能会更清晰。然后你的POJO可以实现MainIfc接口声明的方法。或者你可以为每个POJO构建一个包装类，使其符合接口，如果你想保持实现你的接口的问题与POJO分开。

理想情况下，一个接口应该公开一些可用于与实现它的类进行交互的方法，并且不需要知道底层的POJO /实现。

public interface MainIfc { 
    public Hash getAttributes(); 
    public setAttributes(Hash attributes); 
} 

class Ifc1 implements MainIfc { 
    private String a1; 
    public String getA1() { 
    return a1; 
    } 
    public void setA1(String a1) { 
    this.a1 = a1; 
    } 
    public Hash getAttributes() { 
    // return a hash with data that MainIfc consumer will need from this POJO 
    } 
    public setAttributes(Hash attributes) { 
    // copy hash attributes to corresponding POJO fields 
    } 
} 

class Ifc2 implements MainIfc { 
    private String x1; 
    private String x2; 
    public String getX1() { 
    return x1; 
    } 
    public void setX1(String x1) { 
    this.x1 = x1; 
    } 
    public String getX2() { 
    return x2; 
    } 
    public void setX2(String x2) { 
    this.x2 = x2; 
    } 
    public Hash getAttributes() { 
    // return a hash with data that MainIfc consumer will need from this POJO 
    } 
    public setAttributes(Hash attributes) { 
    // copy hash attributes to corresponding POJO fields 
    } 
} 

Answer 2

试试看看这个代码。也许这将返回类中的所有方法以及从Object类继承的方法。

public static void main(String[] args) throws ClassNotFoundException { 
     GetIfc getIfc=new GetIfc(); 
     MainIfc clas1s=getIfc.getIfc(1); 
     Class class1= clas1s.getClass(); 
     System.out.println(class1); 
     Method[] mem= class1.getMethods(); 
     for(Method mmm : mem) { 
      System.out.println(mmm.getName()); 
     } 
    } 

Answer 3

这听起来像你想做的事情，而不合逻辑。战略模式或抽象工厂可能很适合您的需求，但目前我不太明白您要达到的目标。你绝对不应该有条件地在这些类上施放和调用不同的方法。如果你真的想继续这个道路，我会建议去反思，如果不是一种选择，你需要灵活性，我可能会用某种地图去。

但我绝对会重新考虑你的设计，如果可能的话。

Answer 4

试试这段代码，我不知道我是否完全理解你的要求，但基于我的理解，我认为下面的代码会做的伎俩。

public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, 
    IllegalArgumentException, InvocationTargetException { 
GetIfc getIfc = new GetIfc(); 
MainIfc clas1s = getIfc.getIfc(1); 
Field[] fields = clas1s.getClass().getDeclaredFields(); 
for (int i = 0; i < fields.length; i++) { 
    Field field = fields[i]; 
    Class fieldClasslasse = field.getType(); 

    if (field.getModifiers() == Modifier.PRIVATE) { 

    // you need to check fieldClass, if it is boolean then initials of the getter could be 'is' instead of 'get' 
    String methodNameGet = "get" + Character.toUpperCase(field.getName().charAt(0)) 
     + field.getName().substring(1); 
    String methodNameSet = "set" + Character.toUpperCase(field.getName().charAt(0)) 
     + field.getName().substring(1); 

    Method methodGet = clas1s.getClass().getDeclaredMethod(methodNameGet, null); 
    Object value = methodGet.invoke(clas1s, null); 
    if (value != null && value instanceof String) { 
     String valueUpper = ((String)value).toUpperCase(); 

     Class[] cArg = new Class[1]; 
     cArg[0] = String.class; 
     Method methodSet = clas1s.getClass().getDeclaredMethod(methodNameSet, cArg); 
     Object[] var = new Object[1]; 
     var[0] = valueUpper; 
     methodSet.invoke((Object) clas1s, var); 
    } 

    } 
} 

} 

关于上面的代码做一点解释：获取对象的所有的Fileds并检查是否是私有财产，如果是的话，就必须有一个公共的getter和setter，你猜基于Java约定，呼叫他们的名字getter，获取值，检查它是否是String类的实例，如果是，则将其设置为UPPERCASE，然后调用setter来设置新值。