Dynamique De La Coulée À L'Aide De Java Réflexion

Je pense qu'il peut y avoir une certaine confusion sur la différence entre Java définitions de classes et d'instances à l'œuvre ici. Vous souhaitez définir les valeurs des champs de cas particuliers, pas les classes elles-mêmes. Quelque chose comme cela peut fonctionner:

Object parentClassInstance = parentClass.newInstance();
Class componentClass = Class.forName(clazz.getName());
Object componentClassInstance = componentClass.newInstance();
Field field = parentClass.getDeclaredField(Introspector
.decapitalize(clazz.getSimpleName()));
field.setAccessible(true);
field.set(parentClassInstance, componentClassInstance);

En regardant l'exemple de code entier, cependant, il est un peu difficile à suivre. Pourquoi avoir une List de Classes, avec un nom comme personClassList, ce qui semblerait indiquer que chaque classe doit être la même classe, Person? Je sens qu'il devrait probablement être plutôt une List<Person> ou peut-être List<Object>, qui vous permettraient d'alimenter avec votre Person cas, pas de la Class objets eux-mêmes.

Modifier pour répondre à la question suivante en commentaire:

J'ai du renvoyer la Liste des instances insetad de Liste alors, comment puis-je taper le cas de la Classe à la Personne de manière dynamique...?

Vous ne pouvez pas lancer de Class à Person, depuis Person est probablement pas une sous-classe de Class.

Au lieu de cela, déclarer votre liste comme un List<Person> au lieu d'un List<Class<?>>

List<Person> personList = new ArrayList<Person>();

Puis ajouter le Person objets au lieu de les Class objets de votre liste en bas de votre première for boucle.

personList.add((Person)parentClassInstance);

Et la boucle à l'arrière doivent changer:

for (Person person : personList) {
System.out.println(person);
}

OriginalL'auteur user506069

J'étais à la recherche de ce même type de réponse et, fondamentalement, ce que tout le monde est de spécifier avec l'Objet est correct. J'ai également créé une liste générique comme List<Object> au lieu du nom de la classe réelle. Ci-dessous est une fonction qui retourne une Liste de type de l'Objet. Je passe le nom de la classe et de la charge que avec la .loadClass. Que de créer un nouvel objet avec cette nouvelle instance de classe avec le .newInstance. Le dList est chargé avec toutes les informations pour chaque objectClass qui est la classe je passe avec celui de la classe de la variable. Le reste est fondamentalement juste dynamiquement en invoquant tous les "set" méthodes au sein de la classe particulière avec les valeurs de l'ensemble de résultats.

protected List<Object> FillObject(ResultSet rs, String className)
{
List<Object> dList = new ArrayList<Object>();
try
{
ClassLoader classLoader = GenericModel.class.getClassLoader();
while (rs.next())
{
Class reflectionClass = classLoader.loadClass("models." + className);
Object objectClass = reflectionClass.newInstance();
Method[] methods = reflectionClass.getMethods();
for(Method method: methods)
{
if (method.getName().indexOf("set") > -1)
{
Class[] parameterTypes = method.getParameterTypes();
for(Class pT: parameterTypes)
{
Method setMethod = reflectionClass.getMethod(method.getName(), pT);
switch(pT.getName())
{
case "int":
int intValue = rs.getInt(method.getName().replace("set", ""));
setMethod.invoke(objectClass, intValue);
break;
case "java.util.Date":
Date dateValue = rs.getDate(method.getName().replace("set", ""));
setMethod.invoke(objectClass, dateValue);
break;
case "boolean":
boolean boolValue = rs.getBoolean(method.getName().replace("set", ""));
setMethod.invoke(objectClass, boolValue);
break;
default:
String stringValue = rs.getString(method.getName().replace("set", ""));
setMethod.invoke(objectClass, stringValue);
break;
}
}
}
}
dList.add(objectClass);
}
}
catch (Exception e)
{
this.setConnectionMessage("ERROR: reflection class loading: " + e.getMessage());
}
return dList;
}

OriginalL'auteur PaperBeatsRock-PFFFT