泛型编程是框架的基础，Flink中可以传递POJO对象的get方法，来作为获取key的途径，这样给开发者足够大的灵活性。理解这个过程，对于加强对泛型编程的理解有很大的帮助。此外，对于传递方法，还用到了@FunctionInterface，注意这个注解并不是强制性的，但它减少了一些错误发生的可能。

KeySelector本身就是一个函数接口，它提供了两个泛化参数：T代表当前处理数据的类型，K代表Key的类型。KeySelector在Flink中用于获取处理数据内的键值。想象一下这样的一个问题：你要对输入的数据的一个字段进行某种计算，但是，使用者只有在使用时才会告诉你：1、数据类型，2、要处理的字段。而且这个过程是分成2次的，首先你将得到数据的类型，然后再得到这个数据要处理字段。KeySelector就是用于处理这样问题的一个接口，通过这个接口，你可以先处理自己的计算逻辑，使用者在使用时传入对应的参数即可。

这里将会实现一个简单的功能模拟这样的过程：使用者提供一个数据类型，以及这个数据类型要获取的字段，程序框架将从实例化的对象中获取对应字段的值。

package com.atguigu.hotitems_analysis.test;

public class App {

    public static void main(String[] args) {
        //要处理的对象实例
        Something something = new Something("apple", 10);

        Worker<Something> worker = new Worker<>();
        worker.doSomething();

        //传递获取Int1方法给GetterWorkder
        //Something::getInt1会具化GetFunction<T, K>中的K，这是因为接口 K get(T value); 的返回值就是K
        //这里有点特殊在于，函数接口的传入是类的非静态方法，而一般使用类的静态方法或者实例的非静态方法
        //实际上，类的非静态方法也是允许的，只不过此时函数接口的第一个参数要作为额外的参数，而且类型必须为此类
        GetterWorker getterWorker1 = worker.toGetterWorker(Something::getInt1);

        //传递获取Str1方法给GetterWorkder
        GetterWorker getterWorker2 = worker.toGetterWorker(Something::getStr1);

        //获取实例对象中的对应值
        System.out.println(getterWorker1.getValue(something));
        System.out.println(getterWorker2.getValue(something));
    }
}
package com.atguigu.hotitems_analysis.test;

//使用者定义的POJO对象
public class Something {

    private String str1;

    private Integer int1;

    public Something(String str1, Integer int1) {
        this.str1 = str1;
        this.int1 = int1;
    }

    public String getStr1() {
        return this.str1;
    }

    public Integer getInt1() {
        return this.int1;
    }
}
package com.atguigu.hotitems_analysis.test;

// 获取属性值函数接口，难点在于理解是如何实现并赋值的
@FunctionalInterface
interface GetFunction<T, K> {
    K get(T value);
}
package com.atguigu.hotitems_analysis.test;

// 处理数据的普通操作的类，同时提供获取属性的工作对象
public class Worker<T> {
    //传入的getFunction会具化K，GetterWorker的泛型参数一个由Worker的实例化过程具化，一个由函数接口参数传入时具化
    public <K> GetterWorker<T, K> toGetterWorker(GetFunction<T, K> getFunction) {
        return new GetterWorker<T, K>(getFunction);
    }

    public void doSomething() {
        System.out.println("Do something");
    }
}
package com.atguigu.hotitems_analysis.test;

//通过函数接口获取对象的属性值
public class GetterWorker<T, K> {

    private GetFunction<T, K> getFunction;

    public GetterWorker(GetFunction<T, K> getFunction) {
        this.getFunction = getFunction;
    }

    public K getValue(T something) {
        return getFunction.get(something);
    }
}

Worker只有一个泛型参数T，比较好理解。难点在于函数接口，函数接口一般会赋值为类的静态方法或者实例的普通方法，但是这里赋值为类的非静态方法，其实这是被允许的，这种情况函数接口中方法的第一个参数要定义为类的实例，而且在使用时要传入实例对象。

函数接口与方法引用

此处的难点单独说明，这里的内容参考《Java核心技术卷一第10版》。

函数接口是为了支持Lambda表达式，同时兼容以前的代码，重点在于方法引用。方法引用等同于Lambda表达式，这样的概念清晰化后，才能够彻底的理解为什么方法引用不需要方法名和函数接口一样，因为Lambda表达式关心的只是参数和返回值，Lambda连名字都没有。

那么，方法引用转换为Lambda表达式的形式是理解对类的非静态方法进行引用的关键。方法引用有三种形式：

  • object::instanceMethod
  • Class::staticMethod
  • Class::instanceMethod

不严谨的用method表示上面三种引用的方法，并假设方法都只有一个参数x。前面两种将被转换为下面的Lambda表达式：

x -> method(x)

第三种就比较特殊了，它将被转换为如下形式：

(o, x) -> o.method(x)

上面的Something::getStr1，由于没有输入参数，所以转换为 (o) -> o.getStr1()，符合了GetFunction的定义，也就能赋值给用GetFunction声明的对象了。所以这里并非是Lambda和方法引用二者的关系不清晰，而是类的非静态方法发生的隐式转换带来了理解的陷阱，需要辨别。