Java8通过Function获取字段名称

迈不过友情╰ 2022-11-05 03:19 197阅读 0赞

> Java8新特性：[https://blog.csdn.net/qq\_40794973/article/details/86882454][https_blog.csdn.net_qq_40794973_article_details_86882454]

--------------------

# 1 code #

import java.io.Serializable;
    import java.util.function.Function;
    /**
     * 使Function获得序列化能力
     *
     * @param <T>
     * @param <R>
     */
    @FunctionalInterface
    public interface Fn<T, R> extends Function<T, R>, Serializable {
    }

import java.beans.Introspector;
    import java.lang.invoke.SerializedLambda;
    import java.lang.reflect.Method;
    import java.util.regex.Pattern;
    public class Reflections {
        private static final Pattern GET_PATTERN = Pattern.compile("^get[A-Z].*");
        private static final Pattern IS_PATTERN = Pattern.compile("^is[A-Z].*");
        /**
         * 注意: 非标准变量（非小驼峰）调用这个方法可能会有问题
         *
         * @param fn
         * @param <T>
         * @return
         */
        public static <T> String fnToFieldName(Fn<T, ?> fn) {
            try {
                Method method = fn.getClass().getDeclaredMethod("writeReplace");
                method.setAccessible(Boolean.TRUE);
                SerializedLambda serializedLambda = (SerializedLambda) method.invoke(fn);
                String getter = serializedLambda.getImplMethodName();
                // 对于非标准变量生成的Get方法这里可以直接抛出异常，或者打印异常日志
                if (GET_PATTERN.matcher(getter).matches()) {
                    getter = getter.substring(3);
                } else if (IS_PATTERN.matcher(getter).matches()) {
                    getter = getter.substring(2);
                }
                return Introspector.decapitalize(getter);
            } catch (ReflectiveOperationException e) {
                throw new RuntimeException(e);
            }
        }
    }

--------------------

# 2 测试 #

/**
     * <dependency>
     *     <groupId>org.projectlombok</groupId>
     *     <artifactId>lombok</artifactId>
     *     <version>1.18.16</version>
     * </dependency>
     */
    @Data
    public class User {
        private String name;
        private Integer age;
        private String hubby;
        private Boolean isRich;
        private Integer cityId;
    }

public class ReflectionsTest {
        @Test
        public void test() {
            String name = Reflections.fnToFieldName(User::getIsRich);
            System.out.println("name => " + name);
        }
    }

Map工具类

/**
     * Map工具类
     *
     * @author clare
     */
    public class MapBuilder {
        private final HashMap<String, Object> hashMap = new HashMap<>();
        private MapBuilder() {
        }
        public static MapBuilder builder() {
            return new MapBuilder();
        }
        public MapBuilder put(String key, Object value) {
            hashMap.put(key, value);
            return this;
        }
        public <T> MapBuilder put(Fn<T, ?> fn, Object value) {
            hashMap.put(Reflections.fnToFieldName(fn), value);
            return this;
        }
        public HashMap<String, Object> build() {
            return this.hashMap;
        }
    }

public class MapBuilderTest {
        @Test
        public void test() {
            HashMap<String, Object> userInfoMap = MapBuilder.builder()
                    .put(User::getName, "张三")
                    .put(User::getAge, 18)
                    .put("hubby", "篮球")
                    .put(User::getIsRich, Boolean.FALSE)
                    .put(User::getCityId, 11)
                    .build();
            System.out.println(userInfoMap);
            //{name=张三, cityId=11, hubby=篮球, age=18, isRich=false}
        }
    }

--------------------

# 3 理解 #

package java.util.function;
    /**
     * 对类型为T的对象应用操作，返回R类型的对象。
     */
    @FunctionalInterface
    public interface Function<T, R> {
        /**
         * 
         */
        R apply(T t);
        /**
         * 
         */
        default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
            Objects.requireNonNull(before);
            return (V v) -> apply(before.apply(v));
        }
        /**
         * 
         */
        default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
            Objects.requireNonNull(after);
            return (T t) -> after.apply(apply(t));
        }
        /**
         * 
         */
        static <T> Function<T, T> identity() {
            return t -> t;
        }
    }

/**
     * 对类型为Integer(T)的对象应用操作，并返回String(R)。
     */
    Function<Integer, String> integerToString = (Integer num) -> {
        return String.valueOf(num);
    };
    String res = integerToString.apply(33);
    System.out.println("res => " + res);

/**
     * People定义了writeReplace方法，并且自定义了writeObject/readObject方法。
     */
    @Data
    public class People implements Serializable {
        /**
         *
         */
        private static final long serialVersionUID = 2659082826995480601L;
        private int age;
        private String name;
        People(int age, String name) {this.age = age;this.name = name;}
        private void writeObject(ObjectOutputStream out) {
            System.out.println("People.writeObject");
        }
        private void readObject(ObjectInputStream in) {
            System.out.println("People.readObject");
        }
        //在执行out.write()方法时会触发这个方法，先调用writeReplace，如果没有writeReplace那么将会调用writeObject方法
        /**
         * 作为People类writeReplace返回值的Kong对象
         *
         * 如果一个序列化类中含有Object writeReplace()方法，那么实际序列化的对象将是作为writeReplace方法返回值的对象，而且序列化过程的依据是实际被序列化对象的序列化实现。
         *
         * @return
         */
        private Object writeReplace() {
            System.out.println("People.writeReplace");
            return new Kong("路人");
        }
    }

public class Kong implements Serializable {
        /**
         *
         */
        private static final long serialVersionUID = -7144694309484327560L;
        public String s;
        Kong(String s) {this.s = s;}
        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
            System.out.println("Kong.writeObject");
        }
        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            System.out.println("Kong.readObject");
        }
    }

public class SerializableTest {
        /**
         * 可以看到 out.writeObject(p); 试图序列化一个People对象，但是由于writeReplace方法的存在，实际上序列化了一个 Kong 对象，在这个过程中调用了Kong定义的writeObject方法，并且在反序列化过程中，得到了一个Kong对象，并且调用了Kong定义的readObject方法。整个过程与People的writeObject/readObject无关。
         *
         * 这也就是说Kong k = (Kong)in.readObject(); 这个过程会依赖in中的实际对象，而不是依赖 out.writeObject(p); 如果people类中的writeReplace方法不存在那么序列化正常会序列化people调用people的writeObject方法。
         */
        @Test
        public void testOut() throws Exception {
            People p = new People(2, "小白");
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("kong.txt"));
            out.writeObject(p);
            out.flush();
            out.close();
            //People.writeReplace
            //Kong.writeObject
        }
        @Test
        public void testIn() throws Exception {
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("kong.txt"));
            Kong k = (Kong) in.readObject();
            in.close();
            System.out.println(k.s);
            //Kong.readObject
            //路人
        }
    }

--------------------

# 4 注意 #

对于非标准变量，前面的方法就不一定适用了

**lombok**

// 源代码
    @Getter
    public class User {
        private String name;
        private Integer aGe;
        private Integer agE;
        private Integer age;
        private Boolean isRich;
    }
    
    // Lombok生成的代码
    public class User {
        private String name;
        private Integer aGe;
        private Integer agE;
        private Integer age;
        private Boolean isRich;
        public User() {}
        // 实际上这里只有3个get方法
        public String getName() {return this.name;}
        public Integer getAGe() {return this.aGe;}
        public Boolean getIsRich() {return this.isRich;}
    }
    
    // 测试
    public class MapBuilderTest {
        @Test
        public void test() {
            HashMap<String, Object> userInfoMap = MapBuilder.builder()
                    .put(User::getName, "张三")
                    .put(User::getAGe, 18)
    //                .put(User::getAgE, 18)  idea不报错，但是运行会报错，这个方法不存在
    //                .put(User::getAge, 18)
                    .put(User::getIsRich, Boolean.FALSE)
                    .build();
            System.out.println(userInfoMap);
            //{name=张三, isRich=false, AGe=18}
        }
    }

使用IDEA的快捷键生成Getter

// IDEA快捷键生成
    public class User {
        private String name;
        private Integer aGe;
        private Integer agE;
        private Integer age;
        private Boolean isRich;
        // 5个Getter方法
        public String getName() {return name;}
        public Integer getaGe() {return aGe;}
        public Integer getAgE() {return agE;}
        public Integer getAge() {return age;}
        public Boolean getRich() {return isRich;}
    }
    
    //
    public class MapBuilderTest {
        @Test
        public void test() {
            HashMap<String, Object> userInfoMap = MapBuilder.builder()
                    .put(User::getName, "张三")
                    .put(User::getaGe, 18)
                    .put(User::getAgE, 19)
                    .put(User::getAge, 20)
                    .put(User::getRich, Boolean.FALSE) // IDEA快捷键生成的是getRich而Lombok生成的是getIsRich
                    .build();
            System.out.println(userInfoMap);
            //{getaGe=18, name=张三, rich=false, agE=19, age=20}
        }
    }

> 1.  [https://www.jb51.net/article/185659.htm][https_www.jb51.net_article_185659.htm]
> 2.  [https://blog.csdn.net/tengdazhang770960436/article/details/99960693][https_blog.csdn.net_tengdazhang770960436_article_details_99960693]
> 3.  [https://segmentfault.com/a/1190000019389160][https_segmentfault.com_a_1190000019389160]

[https_blog.csdn.net_qq_40794973_article_details_86882454]: https://blog.csdn.net/qq_40794973/article/details/86882454
[https_www.jb51.net_article_185659.htm]: https://www.jb51.net/article/185659.htm
[https_blog.csdn.net_tengdazhang770960436_article_details_99960693]: https://blog.csdn.net/tengdazhang770960436/article/details/99960693
[https_segmentfault.com_a_1190000019389160]: https://segmentfault.com/a/1190000019389160