在写接口时，会发现 有的时候图方便 直接返回整个对象，这样是不妥的 但是如果要返回指定的字段和属性 重新set get太累 便想着直接 使用map 来封装返回对象 但是有个问题 map.put("xxname",obj);字段名还要手打 更累，便想到直接使用函数式接口 走Lambda 表达式更快 就有了本次尝试
函数式接口
/**
* @Description 支持序列化的 Function
*/
@FunctionalInterface
public interface MapLambdaFunction<T, R>extends Function<T, R>, Serializable {
}
快捷封装类
/**
*@Description: 简化map封装操作
*/
public class MapLambda<T> {
//封装对象
private Map<String, Object> paramMap = new HashMap<>();
private Map<String,List<Map<String,Object>>> listMap = new HashMap<>();
/**
* @Description: 对象添加操作
* @param: column 字段名称,value 单个属性值
*/
public void putOne(MapLambdaFunction<T, ?> column, Object value) {
String fieldName = getFieldName(column);
paramMap.put(fieldName, value);
}
/**
* @Description: 排除指定字段 exclude
* @param: value 放入完整 对象信息,column 可变参
*/
@SafeVarargs
public final void excludeOne(Object value, MapLambdaFunction<T, ?>... column){
try {
int length = column.length;
if (length > 0){
//排除重复字段
Set<String> stringSet = new HashSet<>(length);
for (MapLambdaFunction<T, ?> tMapLambdaFunction : column) {
String item = getFieldName(tMapLambdaFunction);
stringSet.add(item);
}
//反射截取
Class<?> aClass = value.getClass();
Field[] declaredFields = aClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
//设置可读
declaredField.setAccessible(true);
//排除静态字段
if(Modifier.isStatic(declaredField.getModifiers())){
continue;
}
//获取字段名称
String name = declaredField.getName();
//是否包含
boolean contains = stringSet.contains(name);
if (!contains){
//获取当前字段属性值
Object o = declaredField.get(value);
paramMap.put(name,o);
}
}
}
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
//排除list对象中的字段
/**
* @param: value-> list 数据源, column 排除字段
*/
@SafeVarargs
public final void excludeList(Object value, MapLambdaFunction<T, ?>... column) {
try {
int length = column.length;
if (length > 0){
List<Map<String,Object>> maps = new ArrayList<>(length);
//排除重复字段
Set<String> stringSet = new HashSet<>(length);
for (MapLambdaFunction<T, ?> tMapLambdaFunction : column) {
String item = getFieldName(tMapLambdaFunction);
stringSet.add(item);
}
//反射截取
Class<?> aClass = value.getClass();
if (!aClass.getName().equals("com.github.pagehelper.Page")){
//普通list
List<?> listObj = (List<?>) value;
for (Object next : listObj) {
Map<String,Object> map = new HashMap<>();
Class<?> nextClass = next.getClass();
Field[] declaredFields = nextClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
//设置可读
declaredField.setAccessible(true);
//排除静态字段
if(Modifier.isStatic(declaredField.getModifiers())){
continue;
}
//获取字段名称
String name = declaredField.getName();
//是否包含
boolean contains = stringSet.contains(name);
if (!contains){
//获取当前字段属性值
Object o = declaredField.get(next);
map.put(name,o);
}
}
maps.add(map);
}
}else {
//若为分页插件
PropertyDescriptor[] ps = Introspector.getBeanInfo(aClass, Object.class).getPropertyDescriptors();
for (PropertyDescriptor prop : ps) {
//prop.getPropertyType() == List.class
if (prop.getPropertyType().isAssignableFrom(List.class)) { //List 集合类型
Object obj = aClass.getMethod(prop.getReadMethod().getName()).invoke(value);
if(obj !=null){
List<?> listObj = (List<?>) obj;
//next list中每一项的 对象值
for (Object next : listObj) {
Map<String,Object> map = new HashMap<>();
Class<?> nextClass = next.getClass();
Field[] declaredFields = nextClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
//设置可读
declaredField.setAccessible(true);
//排除静态字段
if(Modifier.isStatic(declaredField.getModifiers())){
continue;
}
//获取字段名称
String name = declaredField.getName();
//是否包含
boolean contains = stringSet.contains(name);
if (!contains){
//获取当前字段属性值
Object o = declaredField.get(next);
map.put(name,o);
}
}
maps.add(map);
}
}
}
}
}
listMap.put("list",maps);
}
} catch (Exception e) {
e.printStackTrace();
}
}
//获取反射字段名称
private String getFieldName(MapLambdaFunction<T, ?> column) {
String fieldName = null;
try {
//获取序列化后的对象
Method writeReplace = column.getClass().getDeclaredMethod("writeReplace");
writeReplace.setAccessible(true);
SerializedLambda serializedLambda = (SerializedLambda)writeReplace.invoke(column);
String getterName = serializedLambda.getImplMethodName();
//获取字段名称
fieldName = Introspector.decapitalize(getterName.replace("get", ""));
} catch (Exception e) {
e.printStackTrace();
}
return fieldName;
}
//返回结果集
public Map<String, Object> toMap() {
return paramMap;
}
//返回list
public List<Map<String, Object>> toList() {
List<Map<String, Object>> list = listMap.get("list");
return list;
}
}
测试实体类
public class User implements Serializable {
private String id;
private String name;
private Integer age;
private Integer sex;
private String art1;
private String art2;
private String art3;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Integer getSex() {
return sex;
}
public void setSex(Integer sex) {
this.sex = sex;
}
public String getArt1() {
return art1;
}
public void setArt1(String art1) {
this.art1 = art1;
}
public String getArt2() {
return art2;
}
public void setArt2(String art2) {
this.art2 = art2;
}
public String getArt3() {
return art3;
}
public void setArt3(String art3) {
this.art3 = art3;
}
@Override
public String toString() {
return "User{" +
"id='" + id + ''' +
", name='" + name + ''' +
", age=" + age +
", sex=" + sex +
", art1='" + art1 + ''' +
", art2='" + art2 + ''' +
", art3='" + art3 + ''' +
'}';
}
}
测试类
public class TestTool {
public static void main(String[] args) {
putObjOne();
excludeObjOne();
excludeObjList();
}
private static void excludeObjList() {
List<User> userList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
User user = new User();
user.setId("1"+i);
user.setName("张三"+i);
user.setAge(16+i);
user.setSex(1);
user.setArt1("1");
user.setArt2("2");
user.setArt3("3");
userList.add(user);
}
MapLambda<User> mapLambda = new MapLambda<>();
//传入数据源，传入排除字段
mapLambda.excludeList(userList,User::getArt1,User::getArt2,User::getArt3,User::getId);
//收集为新的list
List<Map<String, Object>> maps = mapLambda.toList();
System.out.println("排除对象字段后list："+maps);
}
//排除 对象中字段
private static void excludeObjOne() {
MapLambda<User> mapLambda = new MapLambda<>();
User user = new User();
user.setId("1");
user.setName("张三");
user.setAge(16);
user.setSex(1);
user.setArt1("1");
user.setArt2("2");
user.setArt3("3");
mapLambda.excludeOne(user,User::getArt1,User::getArt2,User::getArt3);
Map<String, Object> objectMap = mapLambda.toMap();
System.out.println("排除对象字段："+objectMap);
}
//封装新map
private static void putObjOne() {
MapLambda<User> mapLambda = new MapLambda<>();
User user = new User();
user.setId("1");
user.setName("张三");
user.setAge(16);
user.setSex(1);
user.setArt1("1");
user.setArt2("2");
user.setArt3("3");
mapLambda.putOne(User::getId,user.getId());
mapLambda.putOne(User::getName,user.getName());
Map<String, Object> objectMap = mapLambda.toMap();
System.out.println("封装新map："+objectMap);
}
}
效果展示
