Dieses Mal möchte ich vorstellen, wie Sie mit BeanWrapper von Spring Framework dynamisch auf die durch die Zeichenfolge angegebene Eigenschaft zugreifen können.
Eine kurze Beschreibung von "BeanWrapper" lautet "API zum Festlegen und Abrufen von Eigenschaftswerten ohne Verwendung von Setzern und Gettern".
Wenn Sie an eine Bibliothek denken, die dynamisch auf Eigenschaften zugreift, denken Sie möglicherweise an "Apache Commons BeanUtils", jedoch für denselben Zweck. Es ist eine Funktion von.
Offizielle Richtlinien für Spring Framework (Core) "3.4. Bean-Manipulation und Bean Wrapper" Aber es ist gut eingeführt. Die grundlegende Verwendung ist wie folgt.
setPropertyValue einen Wert für eine Eigenschaft festDie Regeln für die Angabe von Eigenschaften (Ausdrücke) sind ebenfalls in den offiziellen Richtlinien enthalten.
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 |
Die grundlegende Verwendung wird erklärt, aber leider gibt es kein Beispiel für den Betrieb der Sammlung (account [2] oder account [COMPANYNAME]).
Dieses Mal möchte ich ein Beispiel dieser Sammlung erklären.
Bei der Bearbeitung von Sammlungseigenschaften hängt die Verwendung von der Bearbeitungstiefe ab. Dieses Mal möchte ich die folgenden zwei Muster erklären.
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) {
//Legen Sie die Elemente fest, die in der Sammlung gespeichert werden sollen
test01();
//Legen Sie Werte für die Eigenschaften der in der Auflistung gespeicherten Elemente fest
test02();
}
//★ Punkt 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));
}
}
//Legen Sie die Elemente fest, die in der Sammlung gespeichert werden sollen
private static void test01() {
try {
//★ Punkt 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("Notebook");
notepc.setPrice(100000);
Item book = new Item();
book.setItemName("Eine gründliche Einführung in den Frühling");
book.setPrice(4000);
Map<String, Object> input = new HashMap<>();
input.put("teamId", "01234");
input.put("teamName", "HelloWorld");
input.put("point", 100);
//★ Punkt 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();
}
}
//Legen Sie Werte für die Eigenschaften der in der Auflistung gespeicherten Elemente fest
private static void test02() {
try {
//★ Punkt 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);
//★ Punkt 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", "Notebook");
input.put("items[A01].price", 100000);
input.put("items[A02].itemName", "Eine gründliche Einführung in den Frühling");
input.put("items[A02].price", 4000);
setPropertyValues(team, input);
System.out.println(team);
} catch(Exception e) {
e.printStackTrace();
}
}
}
** ★ Punkt 1 **
Erstellen Sie eine Instanz von BeanWrapper.
org.springframework.beans.BeanWrapper ist eine Schnittstelle.
Die Implementierungsklasse ist org.springframework.beans.BeanWrapperImpl, und es gibt mehrere Konstruktoren, aber dieses Mal verwenden wir den, der ein Objekt als Argument verwendet.
Verwenden Sie die Methode setPropertyValue, um den Wert festzulegen. Das erste Argument ist die Regel (Ausdruck), die die Eigenschaft angibt, und das zweite Argument ist der Wert, den Sie festlegen möchten.
Weitere Informationen finden Sie unter Javadoc.
** ★ Punkt 2 ** Bei "Festlegen der Elemente, die in der Sammlung gespeichert werden sollen" muss die Zielsammlung instanziiert werden. Der Inhalt der Sammlung ist nicht erforderlich.
** ★ Punkt 3 **
Um die in der Sammlung zu speichernden Elemente festzulegen, geben Sie mit [] die Position der Elemente in der Sammlung an.
** ★ Punkt 4 ** Wenn Sie einen Wert für eine Eigenschaft eines in einer Auflistung gespeicherten Elements festlegen möchten, muss dieses Element der Zielauflistung ebenfalls instanziiert werden.
** ★ Punkt 5 ** Nachdem Sie den Speicherort der Sammlung mit "[]" angegeben haben, geben Sie die Eigenschaft an, die mit ". Property name" festgelegt werden soll. Eine Ausnahme wird ausgelöst, wenn die Elemente der Zielsammlung nicht instanziiert werden. Daher ist es notwendig, das zu betätigende Element an ★ Punkt 4 im Voraus zu instanziieren.
Als Referenz werden die Modellklassen aufgelistet, damit Sie die verschachtelte Auflistung sehen können.
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();
}
}
Dieses Mal habe ich erklärt, wie Sie mit BeanWrapper von Spring Framework dynamisch auf die durch die Zeichenfolge angegebene Eigenschaft zugreifen können.
** Es ist ein praktischer "BeanWrapper", aber es ist natürlich besser, gewöhnlichen "Setter, Getter" für die Verarbeitungsleistung zu verwenden. ** ** **
Ich denke, die Verwendung von "BeanWrapper" ist (1) eine allgemeine Verarbeitung, die einen dynamischen Zugriff erfordert, und (2) das Festlegen von Eingabewerten in der Testklasse, indem die Bequemlichkeit genutzt wird, Eigenschaften mit Zeichenfolgen angeben zu können.