一、函数式接口是jdk8的新特性之一，函数式接口是只包含一个抽象方法声明的接口。按分类主要分为四大接口类型: Function、Consumer、Predicate、Supplier。

接口	参数	返回值	说明
`Supplier<T>`	无	T	供给型，无参，返回一个指定泛型的对象
`Consumer<T>`	T	无	消费型，传入一个指定泛型的参数，无返回值
`Predicate<T>`	T	Boolean	断言型，判断函数，返回true或者false
`Function<T,R>`	T	R	方法型，输入一个参数，返回一个结果

也可以直接去java.util.function包里面看，jdk提供了很多函数式接口。比如

序号	函数式接口	描述说明
1	`BiConsumer<T,U>`	代表了一个接受两个输入参数的操作，并且不返回任何结果
2	`BiFunction<T,U,R>`	代表了一个接受两个输入参数的方法，并且返回一个结果

二、实战：用函数式接口实现回调

员工执行业务逻辑完成任务后，老板收到回调通知。

1.Employee员工类

/**
 * 员工类
 *
 * @author zsh
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Employee<T, C> {
    /**
     * 员工的名字
     */
    private String name;
    /**
     * 员工处理任务的逻辑
     */
    private Function<T, C> taskFunction;

    /**
     * 处理任务的方法
     *
     * @param boss 发布任务的老板对象，包含老板名称，任务及回调
     */
    protected void doTask(Boss<T, C> boss) {
        if (null == boss || null == boss.getTask()) {
            throw new IllegalArgumentException("boss is not ready...");
        }
        if (null == this.taskFunction) {
            throw new IllegalArgumentException("employee has no skills for task...");
        }
        //执行任务的实际方法
        C callback = taskFunction.apply(boss.getTask());
        //将结果发送给老板
        boss.callback(this, callback);
    }
}

2.Boss老板类

/**
 * 老板类
 *
 * @author zsh
 */

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Boss<T, C> {
    /**
     * 老板的名字
     */
    private String name;
    /**
     * 老板待发布的任务
     */
    private T task;
    /**
     * 老板处理回调的方法
     */
    private BiConsumer<Employee<T, C>, C> callbackConsumer;

    /**
     * 指定员工去完成老板的任务
     * 员工完成任务后回调老板的接口
     *
     * @param employee 指定的员工
     */
    public void assignTask(Employee<T, C> employee) {
        employee.doTask(this);
    }

    /**
     * 完成任务后的回调
     *
     * @param employee
     * @param callback
     */
    protected void callback(Employee<T, C> employee, C callback) {
        if (null != callback && null != callbackConsumer) {
            callbackConsumer.accept(employee, callback);
        }
    }
}

3.CallBackService回调service

/**
 * 回调service
 *
 * @author zsh
 */
@Service
public class CallBackService {
    /**
     * 回调方法
     */
    public <T, C> void bossAssignTask() {
        //初始化老板对象，指定名称，任务和处理回调的逻辑
        Boss<T, C> bossA = new Boss<>(
                "bossA",
                (T) "a任务",
                (e, c) -> System.out.println("BossA收到" + e.getName() + "的回调啦..." + c.toString())
        );
        //初始化员工对象，指定名称和处理任务的逻辑
        Employee<T, C> employee = new Employee<>(
                "employee",
                t -> {
                    System.out.println("【员工A】收到任务" + t.toString() + "啦...");
                    try {
                        //通过睡眠，模拟执行任务
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("【员工A】完成任务" + t.toString() + "啦...");
                    return (C) "确认了处理结果";
                });
        //老板给员工安排任务，员工完成任务后老板会收到回调
        bossA.assignTask(employee);
        //员工可以换一个处理这个任务的逻辑
        employee.setTaskFunction(t -> {
            System.out.println("【员工A新逻辑】收到任务" + t.toString() + "啦...");
            try {
                //通过睡眠，模拟执行任务
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("【员工A新逻辑】完成任务" + t.toString() + "啦...");
            return (C) "确认了新逻辑处理结果";
        });
        //老板继续给员工安排任务
        bossA.assignTask(employee);
        //老板有了新任务
        bossA.setTask((T) "b任务");
        //老板继续给员工安排任务
        bossA.assignTask(employee);
        //老板有新的回调逻辑
        bossA.setCallbackConsumer((e, c) -> System.out.println("BossA新的回调方法收到" + e.getName() + "的回调啦..." + c.toString()));
        //老板继续给员工安排任务
        //bossA.assignTask(employee);
    }
}

4.CallBackController回调controller

/**
 * 回调Controller
 *
 * @author zsh
 */
@RestController
@RequestMapping("/callBackController")
public class CallBackController {
    @Autowired
    private CallBackService callBackService;

    @RequestMapping("/callBackBossAssignTask")
    public boolean callBackBossAssignTask() {
        callBackService.bossAssignTask();
        return true;
    }

}