JavaBean
JavaBean
确保工程中有以下依赖:
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
</dependency>
获取getter和setter
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
private static final Pattern GET_PATTERN = Pattern.compile("^get[A-Z].*");
private static final Pattern SET_PATTERN = Pattern.compile("^set[A-Z].*");
/**
* 获取对象中的所有 getter 方法
*
* @param obj 要获取方法的对象
* @return 包含所有 getter 方法的列表
*/
public static List<Method> getGetterMethods(Object obj) {
List<Method> getterMethods = new ArrayList<>();
Method[] methods = obj.getClass().getMethods();
for (Method method : methods) {
Matcher matcher = GET_PATTERN.matcher(method.getName());
if (matcher.matches() && method.getParameterTypes().length == 0) { // 标准的 getter 方法是不带参数的方法
getterMethods.add(method);
}
}
return getterMethods;
}
/**
* 获取对象中的所有 setter 方法
*
* @param obj 要获取方法的对象
* @return 包含所有 setter 方法的列表
*/
public static List<Method> getSetterMethods(Object obj) {
List<Method> setterMethods = new ArrayList<>();
Method[] methods = obj.getClass().getMethods();
for (Method method : methods) {
Matcher matcher = SET_PATTERN.matcher(method.getName());
if (matcher.matches() && method.getParameterTypes().length == 1) { // 正则校验以及检查一个方法是否只有一个参数(因为 setter 方法通常只有一个参数,用于设置属性的新值)
setterMethods.add(method);
}
}
return setterMethods;
}
/**
* 示例用法
*/
public static void main(String[] args) {
// 示例用法
Person person = new Person();
List<Method> getterMethods = getGetterMethods(person);
List<Method> setterMethods = getSetterMethods(person);
System.out.println("Getter 方法:");
for (Method method : getterMethods) {
System.out.println("Getter 方法名: " + method.getName());
}
System.out.println("Setter 方法:");
for (Method method : setterMethods) {
System.out.println("Setter 方法名: " + method.getName());
}
}
/**
* 示例中的 Person 类
*/
public static class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
}
打印结果:
Getter 方法:
Getter 方法名: getName
Getter 方法名: getAge
Getter 方法名: getClass
Setter 方法:
Setter 方法名: setName
Setter 方法名: setAge
Map
JavaBean 转 Map
BeanMap.create
用于创建一个能够操作 JavaBean 属性的 Map
。这个 Map
允许你通过键值对的方式访问和修改 JavaBean 对象的属性,而无需直接调用对象的 getter
和 setter
方法。这个方法返回的 Map
类型是 BeanMap
import org.springframework.cglib.beans.BeanMap;
public class BeanMapExample {
public static void main(String[] args) throws Exception {
// 创建一个简单的 JavaBean 对象
Person person = new Person();
person.setName("John");
person.setAge(25);
// 使用 BeanMap.create 创建 BeanMap
BeanMap beanMap = BeanMap.create(person);
// 通过 Map 操作 JavaBean 的属性
System.out.println("Original Name: " + beanMap.get("name"));
// 修改属性值
beanMap.put("name", "Jane");
// 通过 Map 获取修改后的属性值
System.out.println("Updated Name: " + beanMap.get("name"));
// 通过 Map 操作 JavaBean 的其他属性
System.out.println("Age: " + beanMap.get("age"));
}
public static class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
}
Map 转 JavaBean
mapToBean
方法接受一个 Map
和目标 Class
,然后使用反射实例化一个新的 JavaBean 对象,最后通过 BeanMap.create(bean).putAll(map)
将 Map
中的键值对映射到 JavaBean 对象的属性
import org.springframework.cglib.beans.BeanMap;
import org.springframework.objenesis.instantiator.util.ClassUtils;
import java.util.HashMap;
import java.util.Map;
public class BeanMapExample {
public static void main(String[] args) throws Exception {
// 创建一个示例的Map
Map<String, Object> dataMap = new HashMap<>();
dataMap.put("name", "John Doe");
dataMap.put("age", 30);
// 调用mapToBean方法将Map映射到一个JavaBean对象
Person person = mapToBean(dataMap, Person.class);
// 输出映射后的JavaBean对象的属性值
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
}
public static <T> T mapToBean(Map<String, ?> map, Class<T> clazz) {
T bean = ClassUtils.newInstance(clazz);
BeanMap.create(bean).putAll(map);
return bean;
}
public static class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
}
List
JavaBean 转 List<Map>
import com.mw.commons.utils.bean.BeanMapUtils;
import org.springframework.util.CollectionUtils;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
// 假设有一个包含不同类型对象的列表
List<Person> peoples = Arrays.asList(new Person("John", 25), new Person("Jane", 30));
// 调用 beansToMaps 方法进行转换
List<Map<String, Object>> maps = beansToMaps(peoples);
// 打印转换后的结果
for (Map<String, Object> map : maps) {
System.out.println(map);
}
}
public static <T> List<Map<String, Object>> beansToMaps(List<T> beans) {
if (CollectionUtils.isEmpty(beans)) {
return Collections.emptyList();
}
/**
* beans 是一个列表,通过调用 stream() 方法将其转换为流。这样可以使用流操作对列表中的元素进行处理
* map 是一个中间操作,它接受一个函数作为参数,该函数将每个元素映射到另一个元素。在这里,BeanMapUtils::beanToMap 是一个方法引用,表示将 beanToMap 方法应用于流中的每个元素。这就是说,对于列表中的每个对象,都会调用 beanToMap 方法
* collect 是一个终端操作,它接受将流元素累积到一个可变结果容器中的收集器。在这里,Collectors.toList() 是一个收集器,用于将流中的元素收集到一个 List 中
*/
return beans.stream().map(BeanMapUtils::beanToMap).collect(Collectors.toList());
}
public static class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
}
List<Map>
转 JavaBean
import org.springframework.cglib.beans.BeanMap;
import org.springframework.objenesis.instantiator.util.ClassUtils;
import org.springframework.util.CollectionUtils;
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
// 假设有一个包含不同类型的 Map 对象的列表
List<Map<String, ?>> maps = new ArrayList<>();
Map<String, Object> map1 = new HashMap<>();
map1.put("name", "John");
map1.put("age", 25);
Map<String, Object> map2 = new HashMap<>();
map2.put("name", "Jane");
map2.put("age", 30);
maps.add(map1);
maps.add(map2);
// 调用 mapsToBeans 方法进行转换
List<Person> people = mapsToBeans(maps, Person.class);
// 打印转换后的结果
for (Person person : people) {
System.out.println("Name: " + person.getName() + ", Age: " + person.getAge());
}
}
public static class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public static <T> List<T> mapsToBeans(List<? extends Map<String, ?>> maps, Class<T> clazz) {
if (CollectionUtils.isEmpty(maps)) {
return Collections.emptyList();
}
/**
* maps 是一个列表,通过调用 stream() 方法将其转换为流。这样可以使用流操作对列表中的元素进行处理
* map 是一个中间操作,它接受一个函数作为参数,该函数将每个流元素映射为另一个元素。在这里,e -> mapToBean(e, clazz) 是一个 Lambda 表达式,表示将 mapToBean 方法应用于流中的每个元素 (e)。这就是说,对于列表中的每个 Map 对象,都会调用 mapToBean 方法,将其转换为指定类型的对象
* collect 是一个终端操作,它接受将流元素累积到一个可变结果容器中的收集器。在这里,Collectors.toList() 是一个收集器,用于将流中的元素收集到一个 List 中
*/
return maps.stream().map(e -> mapToBean(e, clazz)).collect(Collectors.toList());
}
public static <T> T mapToBean(Map<String, ?> map, Class<T> clazz) {
T bean = ClassUtils.newInstance(clazz);
BeanMap.create(bean).putAll(map);
return bean;
}
}
Powered by Waline v3.0.0-alpha.11