Java8函数式接口思考之异步托付

什么是函数式接口

仅有一个笼统办法,能够具有多个非笼统办法的的接口。

为什么java8有函数式接口

首要，咱们需求明白函数是什么，在数学中函数浅显的意思便是由自变量和因变量所确定的一种联系。而在计算机中，函数则是是一个固定的一个程序段，它在能够完结固定运算功能，而且供给入参和结果出参(入参和出参非有必要),能够浅显的了解为Java中的办法。

public int sum(int a, int b){
    return a + b;
}

在java这个面向目标的言语里，什么都能够被当作一个目标来描述，乃至是一个简略的用户名username，在需求的适合也能够封装成一个UserName目标，具有自己的结构办法和逻辑办法，乃至能够在结构办法中完结结构我(UserName)需求的参数以及校验（例如”我”不能包括灵敏字符）。

那么关于一个函数(办法)也不破例，它也能够被描述成一个目标

public class Sum{
    public int sum(int a, int b){
        return a + b;
    }
}

在函数的基础上，为了多态扩展，函数会当作函数式接口来做不同完结

public interface Sum{
    /**
     * 外部自己完结不同的sum逻辑
     * /
    int sum(int a, int b);
}

一般情况下，接口完结都是经过创立一个类文件，并implements接口的办法来完结的，而这种办法在函数过多的情况下，假如都去完结一遍，往往会形成存在许多的类，形成管理上的紊乱和运用上的不便。

所以在java8之前，Java的做法是接口的匿名完结，在代码中快速完结一个接口的匿名（暂时的完结变量，没用详细继承自接口的类）完结。

例如咱们在创立线程Thread时常用的参数 Runnable接口，在Thread结构办法中，有一个参数 Runnable , 这个Runnable赋值给了Thread的一个成员变量，终究在调用Thread的run办法时（也能够经过start()办法，可是start()办法是调用了native办法去启动的）办法时，run()里调用了runnable的run办法。

源码示例，详细源码能够自行阅读Thread源码：

运用办法：

    public void testTheadRunnable() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名完结了一个runnable接口");
            }
        }).start();
        //等同于
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名完结了一个runnable接口");
            }
        };
        new Thread(runnable).start();
    }

可是！ 关于这样的完结办法，尽管说没有问题，可是代码冗长，写法丑陋(很容易被其它言语开发者轻视)，于是乎，java8对这种场景做了语法糖优化，这种语法糖优化在java8中被称为lambda (此处简略介绍，向后阅读详细介绍)。

lambda语法其实便是匿名完结了一个函数式接口：

    public void testTheadRunnable1() {
        new Thread(() -> System.out.println("Lambda 完结了一个Runnable函数式接口")).start();
        //等同于
        Runnable runnable = () -> System.out.println("Lambda 完结了一个Runnable函数式接口");
        new Thread(runnable).start();
    }

要点来了！！

一个接口能够具有多个笼统办法，假如具有了多个笼统办法，那么它就不满意于计算机中函数”一个固定的一个程序段”的界说。

基于编译言语和复杂度的问题上，为了满意语法糖的推导，于是乎java8中引入了

@FunctionalInterface 注解标识一个函数式接口，该注解会在编译期对接口是否满意函数式接口进行检查：

所以，函数式接口的概念也并非从java8开始的，只不过为了方便lambda语法糖的推导，由是愈加着重这个概念，而且给予规范。

函数式接口和lambda的运用

Lambda 表达式能够经过 匿名完结 和 办法引证 的语法糖进行匿名传递。

匿名完结

匿名完结，能够分为单行完结和多行完结。

//单行完结
new Thread(() -> System.out.println("Lambda 完结了一个Runnable函数式接口")).start();
//多行完结
new Thread(() -> {
  System.out.println("Lambda 完结了一个Runnable函数式接口");
  System.out.println("Lambda 完结了一个Runnable函数式接口");
  System.out.println("Lambda 完结了一个Runnable函数式接口");
}).start();

在单行完结下，不需求办法体大括号，也不需求句子完毕的”;”号结束。

且假如匿名完结的是一个有返回值的函数式接口，会隐式的添加上 return句子。

@FunctionalInterface
public interface Supplier<T> {
    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

    public void testReturn() {
        Supplier<Integer> supplier1 = () -> new Integer(666);
        Integer result1 = supplier1.get();
        //等同于
        Supplier<Integer> supplier2 = () -> {return new Integer(999);};
        Integer result2 = supplier2.get();
    }

无论是单行匿名完结或者是多行匿名完结，lambda表达式前面的() 括号则代表你要匿名完结的函数式接口的笼统办法的入参，假如是无参数笼统办法则是”()->”,有参数则是”(参数)->”，单参数可被简化为 var -> 的办法。 示例：

无参数示例

对应

有参数示例

@FunctionalInterface
public interface Sum {
    int sum(int a, int b);
}

单参数

对应

办法引证

能够经过办法引证来匿名完结一个函数式接口，语法

目标::办法  或  静态类::静态办法

    @FunctionalInterface
    public interface Requester {
        void request();
    }
    public void testRefVar() {
        //引证runMethod办法，匿名完结了executeMethod 形参的Requester函数式接口
        this.executeMethod(this::runMethod);
    }
    public void executeMethod(Requester requester) {
        requester.request();
    }
    public void runMethod() {
        System.out.println("恳求中...");
        System.out.println("恳求完结！");
    }

被引证的办法需求和匿名完结的函数式接口的笼统办法具有相同的入参出参。

    @FunctionalInterface
    public interface Sum {
        int sum(int a, int b);
    }
    public void testRefVar() {
        //引证runMethod办法，匿名完结了executeMethod 形参的Sum函数式接口
        this.executeMethod(this::runMethod);
    }
    public void executeMethod(Sum sum) {
        int x = 6;
        int y = 9;
        sum.sum(x, y);
    }
    public int runMethod(int a, int b) {
        return a + b;
    }

函数式编程的思想提高 托付与异步编程

到此为止，咱们需求思考一个问题，函数式接口能为咱们带来哪些编程思想上提高呢？从我个人的了解上，能够总结为两点

1. 托付
2. 异步编程

托付：如其名意，在java中能够了解为，某个目标A将某个逻辑托付给调用其办法的B目标来完结。

异步编程：这儿的异步并非开启一个编程异步履行的意思，而是指你在实际编码办法的异步，指的是不必依照一连串代码的串行编码。在写某段逻辑触发的代码时，这段代码片段已经提早被写好了，还没有被履行，只是在需求的时候履行调用。

举个比如，相似前端编程言语中常见的回调办法，B目标调用A目标的A1办法，而且在办法参数中传递了一个回调办法，A目标A1办法中在某种场景下履行了B目标传递的回调办法，这个场景在前端言语中十分常见。而在Java中言语编程过程中，其实也有常见的写法，相似规划形式中的观察者形式等。

可是一个逻辑就要经过规划形式的办法来做，无疑有点大炮打小鸟的意味。而运用函数式接口，则能够快速明晰的完结，举例上述场景：

    public static class A {
        public void a1(Runnable call) {
            //do something
            System.out.println("只因泥太煤");
            if (Boolean.TRUE) {
                call.run();
            }
        }
    }
    public static class B {
        public void b1() {
            A a = new A();
            a.a1(() -> System.out.println("小黑子真虾头"));
        }
    }

在这个简略的比如当中，托付和异步编程体现在哪里呢？

托付：A目标的a1办法将一个回调办法的完结托付给调用其的目标自己完结，A目标的a1办法中，仅有自己的逻辑，不包括调用其办法的其他办法的业务逻辑，责任分明。

异步编程：回调办法由B目标已经提早写好了，在写这段代码时，这个回调办法并未被履行，而是A目标的a1调用时，才真正被履行。关于A目标和B目标来说，在编码上这无疑都是异步的。

在Java8供给的一些开发工具类中，咱们能很频繁的见到这种运用办法，相信大家在日常开发过程中必定也是高频运用，举例咱们在java8常用的Optional

Optional

ifPresent办法，Optional只完结存在则履行的责任，详细的履行逻辑经过Consumer函数式接口参数托付给调用者自己完结。

orElseGet办法,Optional只完结”获取和不存在则获取”的责任，将不存在的获取办法经过Supplier函数式接口参数托付给调用者自己完结。

orElseThrow办法,Optional只完结”获取和不存在则抛出反常”的责任，将不存在需求抛出的反常经过Supplier函数式接口参数托付给调用者自己来生成。

运用示例：

    public void testOptional(Object obj) {
        Optional<Object> objOptional = Optional.ofNullable(obj);
        //假如存在履行
        objOptional.ifPresent(o -> System.out.println(o.toString()));
        //假如不存在调用supplier获取
        Object o = objOptional.orElseGet(Object::new);
        //假如不存在,调用supplier获取反常抛出
        Object o1 = objOptional.orElseThrow(() -> new RuntimeException("空空如也"));
    }

代码简练洁净，言简意骇，举个”反例”:

    public void testOptional1(Object obj) {
        //假如存在履行
        if (obj != null) {
            System.out.println("666");
        }
        //假如不存在获取
        Object object = null;
        if (obj != null) {
            object = obj;
        } else {
            object = new Object();
        }
        //假如不存在,则抛出反常抛出
        Object object1 = null;
        if (obj != null) {
            object1 = obj;
        } else {
            throw new RuntimeException("空空如也");
        }
    }

乃至，你还能够运用这些玩一些”花活”，咱们经常在代码的碰到过同类办法调用时，假如被调用的办法是运用spring的aop来做署理完结的情况时，例如@Transactional 或 @Cacheable，往往会由于同类调用无法署理导致失效（尽管这种情况往往是由于自己层级责任区分过错导致）,一旦遭受这种问题，大部分人的做法是，将办法拆到另一个类中或者手动从ioc容器中获取或者注入bean来完结署理。而在这儿，咱们其实经过函数式接口托付的办法，来做一个一致的署理类。

示例:

@Component
public class TransactionalManager {
    @Transactional
    public void runTransaction(Runnable runnable){
        runnable.run();
    }
}

改为增加一个TransactionalManager

@Component
public class Test {
    @Autowired
    private TransactionalManager transactionalManager;
    public void a(){
        //署理失利,由于spring是经过aop署理完结的。
        this.b();
        //业务署理成功
        transactionalManager.runTransaction(this::b);
    }
    @Transactional
    public void b(){
        System.out.println("业务");
    }
}

经过完结一个业务的Manager类，责任便是帮助完结业务署理，这样b办法就能够不用拆到别的类当中去了。

题外话，假如跳出Java这个编程文化圈来看，假如是写过前端JavaScript的小伙伴, 其实对这种函数编程其实是如同吃饭喝水一样习惯了，由于前端js为了用户体验，渲染速度等，一定是经常运用异步的，而异步回调上经常也是经过传递函数完结的，写过js的同学一定运用过十分好用的东西：Promise， Promise能够很好的处理异步回调的问题，例如：

 var promise = new Promise(function(resolve, reject){
        //异步
        setTimeout(function(){
            resolve('异步完结，履行回调');
        }, 2000);
    });
promise.then(res=> console.log(res))
//输出'异步完结，履行回调'

你不了解JavaScript其实也没联系，也不Promise工作原理，可是你从共通代码其实不丑陋出，其便是基于函数托付给Promise履行回调来工作的，不能的言语，其实思想上许多都是相通的。