Cette fois, je voudrais vous présenter comment accéder dynamiquement à la propriété spécifiée par la chaîne de caractères en utilisant BeanWrapper de Spring Framework.
Une brève description de BeanWrapper est" API pour définir et récupérer les valeurs de propriété sans utiliser Setters et Getters ".
Quand vous pensez à une bibliothèque qui accède dynamiquement aux propriétés, vous pourriez penser à "Apache Commons BeanUtils", mais dans le même but. C'est une fonction de.
Directives officielles de Spring Framework (Core) "3.4. Manipulation de Bean et Bean Wrapper" Mais c'est bien présenté. L'utilisation de base est la suivante.
BeanWrappersetPropertyValuegetPropertyValueLes règles de spécification des propriétés (expressions) sont également incluses dans les directives officielles.
Table 11. Examples of properties
| Expression | Explanation |
|---|---|
| name | Indicates the property name corresponding to the methods getName() or isName() and setName(..) |
| account.name | Indicates the nested property name of the property account corresponding e.g. to the methods getAccount().setName() or getAccount().getName() |
| account[2] | Indicates the third element of the indexed property account. Indexed properties can be of type array, list or other naturally ordered collection |
| account[COMPANYNAME] | Indicates the value of the map entry indexed by the key COMPANYNAME of the Map property account |
L'utilisation de base est expliquée, mais malheureusement il n'y a pas d'exemple pour manipuler les collections (ʻaccount [2] ʻet ʻaccount [COMPANYNAME] `). Cette fois, je voudrais expliquer un échantillon de cette collection.
Lors de la manipulation des propriétés d'une collection, l'utilisation dépend de la profondeur de la manipulation. Cette fois, je voudrais expliquer les deux modèles suivants.
BeanWrapperDemo.java
package demo;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
public class BeanWrapperDemo {
public static void main(String[] args) {
//Définir les éléments à stocker dans la collection
test01();
//Définir les valeurs des propriétés des éléments stockés dans la collection
test02();
}
//★ Point 1
private static void setPropertyValues(Object target, Map<String, Object> input) {
BeanWrapper wrapper = new BeanWrapperImpl(target);
for (String key : input.keySet()) {
wrapper.setPropertyValue(key, input.get(key));
}
}
//Définir les éléments à stocker dans la collection
private static void test01() {
try {
//★ Point 2
Team team = new Team();
List<Member> memberList = new ArrayList<>();
Map<String, Item> items = new HashMap<>();
team.setMemberList(memberList);
team.setItems(items);
Member taro = new Member();
taro.setMail("[email protected]");
taro.setName("TARO YAMADA");
Member hanako = new Member();
hanako.setMail("[email protected]");
hanako.setName("HANAKO TOYOSU");
Item notepc = new Item();
notepc.setItemName("Ordinateur portable");
notepc.setPrice(100000);
Item book = new Item();
book.setItemName("Une introduction approfondie au printemps");
book.setPrice(4000);
Map<String, Object> input = new HashMap<>();
input.put("teamId", "01234");
input.put("teamName", "HelloWorld");
input.put("point", 100);
//★ Point 3
input.put("memberList[0]", taro);
input.put("memberList[1]", hanako);
input.put("items[A01]", notepc);
input.put("items[A02]", book);
setPropertyValues(team, input);
System.out.println(team);
} catch(Exception e) {
e.printStackTrace();
}
}
//Définir les valeurs des propriétés des éléments stockés dans la collection
private static void test02() {
try {
//★ Point 4
Team team = new Team();
List<Member> memberList = new ArrayList<>();
memberList.add(new Member());
memberList.add(new Member());
Map<String, Item> items = new HashMap<>();
items.put("A01", new Item());
items.put("A02", new Item());
team.setMemberList(memberList);
team.setItems(items);
Map<String, Object> input = new HashMap<>();
input.put("teamId", "01234");
input.put("teamName", "HelloWorld");
input.put("point", 100);
//★ Point 5
input.put("memberList[0].mail", "[email protected]");
input.put("memberList[0].name", "TARO YAMADA");
input.put("memberList[1].mail", "[email protected]");
input.put("memberList[1].name", "HANAKO TOYOSU");
input.put("items[A01].itemName", "Ordinateur portable");
input.put("items[A01].price", 100000);
input.put("items[A02].itemName", "Une introduction approfondie au printemps");
input.put("items[A02].price", 4000);
setPropertyValues(team, input);
System.out.println(team);
} catch(Exception e) {
e.printStackTrace();
}
}
}
** ★ Point 1 **
Créez une instance de BeanWrapper.
ʻOrg.springframework.beans.BeanWrapper est une interface. La classe d'implémentation est ʻorg.springframework.beans.BeanWrapperImpl, et il y a plusieurs constructeurs, mais cette fois nous utiliserons celui qui prend un objet comme argument.
Utilisez la méthode setPropertyValue pour définir la valeur. Le premier argument est la règle (Expression) qui spécifie la propriété et le deuxième argument est la valeur que vous souhaitez définir.
Voir Javadoc pour plus d'informations.
** ★ Point 2 ** Lorsque "Définir les éléments à stocker dans la collection", la collection cible doit être instanciée. Le contenu de la collection n'est pas nécessaire.
** ★ Point 3 **
Pour définir les éléments à stocker dans la collection, utilisez [] pour spécifier la position des éléments dans la collection.
List (liste ordonnée, tableau), spécifiez l'index à utiliser (à partir de 0) dans [].Map, spécifiez la clé à utiliser dans [].** ★ Point 4 ** Si vous souhaitez définir une valeur pour une propriété d'un élément stocké dans une collection, cet élément de la collection cible doit également être instancié.
List (liste ordonnée, tableau), ajoutez des éléments jusqu'à l'index à exploiter.Map, ajoutez un élément avec la clé à utiliser.** ★ Point 5 ** Après avoir spécifié l'emplacement de la collection avec «[]», spécifiez la propriété à définir avec «. Nom de propriété». Une exception est déclenchée si les éléments de la collection cible ne sont pas instanciés. Par conséquent, il est nécessaire d'instancier l'élément à exploiter au ★ Point 4 à l'avance.
Pour référence, les classes de modèle sont répertoriées afin que vous puissiez voir la collection imbriquée.
Team.java
package demo;
import java.util.List;
import java.util.Map;
public class Team {
private String teamId;
private String teamName;
private int point;
private List<Member> memberList;
private Map<String, Item> items;
// setter,getter omitted
// override toString generated by eclipse
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Team [teamId=");
builder.append(teamId);
builder.append(", teamName=");
builder.append(teamName);
builder.append(", point=");
builder.append(point);
builder.append(", memberList=");
builder.append(memberList);
builder.append(", items=");
builder.append(items);
builder.append("]");
return builder.toString();
}
}
Member.java
package demo;
import java.util.Map;
public class Member {
private String mail;
private String name;
private Map<String, String> memo;
// setter,getter omitted
// override toString generated by eclipse
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Member [mail=");
builder.append(mail);
builder.append(", name=");
builder.append(name);
builder.append(", memo=");
builder.append(memo);
builder.append("]");
return builder.toString();
}
}
Item.java
package demo;
public class Item {
private String itemName;
private int price;
// setter,getter omitted
// override toString generated by eclipse
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Item [itemName=");
builder.append(itemName);
builder.append(", price=");
builder.append(price);
builder.append("]");
return builder.toString();
}
}
Cette fois, j'ai expliqué comment accéder dynamiquement à la propriété spécifiée par la chaîne de caractères en utilisant BeanWrapper de Spring Framework.
** C'est un BeanWrapper pratique, mais bien sûr, il est préférable d'utiliser le" Setter, Getter "ordinaire pour les performances de traitement. ** **
Je pense que l'utilisation de BeanWrapper est (1) un traitement à usage général qui nécessite un accès dynamique, et (2) la définition de valeurs d'entrée dans la classe de test en profitant de la commodité de pouvoir spécifier des propriétés avec des chaînes de caractères.
Recommended Posts