Java 杂谈Java Web知识Java 核心技术

Java巧用lambda,异步方法优雅写法

2019-03-03  本文已影响2人  路过的猪

了解lambda的基本原理

加入lambda之后,很多写法都变得简单起来,如创建一个线程对象,可以:

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.print("Hello");
    }
});

lambda写法:
new Thread(() -> System.out.print("Hello"));

单独将lambda拎出来:
Runnable runnable = () -> System.out.print("Hello");

其实lambda代表的就是一个接口的实现而已(匿名内部类)。而这种接口也叫函数式接口,会有@FunctionalInterface注解进行编译时检查。

或者直接把lambda看成一个方法,上述的 () -> System.out.print("Hello") 就是代表一个无入参、无返回值的一个方法(等同于public void run() {System.out.print("Hello")}),而Runnable runnable则是指向这个方法(类似函数指针),需要调用这个方法时,调用runnable.run()即可.

当有一个参数、无返回值则是Consumer<T>

// 对printStream对象的void print(String s)方法的引用
PrintStream printStream = System.out;
Consumer<String> consumer = printStream::print;
consumer.accept("Hello");

// 输出
Hello

对于有入参(一个或两个)、有返回值等情况,JDK也提供了对应的函数式接口:

接口 函数 说明
Consumer <T>void accept(T t) 无返回值、一个入参,T为入参类型
BiConsumer<T, U> void accept(T t, U u) 无返回值、两个入参,T为第一个入参类型、U为第二个入参类型
Supplier<T> T get() 有返回值、无入参,T为返回值类型
Function<T, R> R apply(T t) 有返回值、一个入参,T为入参类型,R为返回类型
BiFunction<T, U, R> R apply(T t, U u) 有返回值、两个入参,T为第一个入参类型、U为第二个入参类型,R为返回类型

以上为java.util.function包下的部分接口,剩余的基本上就是指定泛型类型的函数接口了,例如LongConsumer,无泛型,其实就是指定入参只能是Long。

上述已经代表了大部分的函数可以表示的形式了(值得注意的是,三个及以上的入参的函数式接口JDK并没有提供,需要时要自定义实现,实际上也很少用到)。

方法有静态方法(static)和非静态方法,但函数式接口关注的仅是入参、出参类型和个数而已:

public Class Test {
    public Long noStaticFoo(String str) {...}
    public static Long staticFoo(String str) {...}
    
    public static void main() {
        // 静态方法,类::
        Function<String, Long> staticFoo = Test::staticFoo;
        Long apply = staticFoo.apply("100");
        
        // 非静态方法,实例对象::
        Test test = new Test();
        Function<String, Long> noStaticFoo = test::noStaticFoo;
        Long apply2 = noStaticFoo.apply("100");
        
        /* 这种可以理解成两个入参、除了原来方法的入参外,还要指明实例对象(因为这是一个实例方法)*/
        BiFunction<Test, String, Long> noStaticFooTest = Test::noStaticFoo;
        Long apply3 = noStaticFooTest.apply(test, "100");
    }
}

当一个函数/方法可以被变量引用时,其实就可以利用这个特性做一些比较方便的事情了,例如Streams的相关API。效率也比反射中的Method要高。

优雅的异步方法调用写法

在java中的异步方法,原理基本上大同小异,其实就是新开一个线程(或者从线程池中获取线程),Spring也提供相应的@Async注解。这里期待的是,将业务代码与“系统是否异步执行”进行解耦。
假如我现在有个Service,里面有个方法是根据id远程拉取用户信息(HTTP):

    public class UserHttpService {
        public User getById(Long id) {
            ...
            return user;
        }
    }

有A、B、C三个地方有调用到UserHttpService#getById,我们发现A处同步发起了好几个HTTP请求(拉取用户信息只是其中一个),这时候我希望UserHttpService#getById能变成异步执行,提高效率。一种做法是@Async + 直接修改返回值为Future,但是问题来了,这样的话B、C两个地方都要做出修改,但是B、C只调了一个HTTP,没必要变成异步呀(事实上,在真实项目中,情况会比这个更加复杂)。另外一种做法则是结合lambda进行解耦。
先新增一个异步执行类:

public class AsyncExecutor {
        // 线程池,建议恰当配置和使用框架注入
        private ExecutorService executorService = Executors.newFixedThreadPool(10);

        /**
        * 单个入参,有返回值的异步执行方法 , public User getById(Long id)
        *
        * @param method 要执行的方法,如 , userHttpService::getById
        * @param param  入参值,如 100
        * @param <P>    入参类型,如 Long
        * @param <R>    返回值类型,如 User
        * @return Future对象,用以判断是否执行结束、获取返回结果
        */
        public <P, R> Future<R> async(Function<P, R> method, P param) {
            return executorService.submit(() -> method.apply(param));
        }
    }

这时候A处异步调用:

public class A {

    private AsyncExecutor asyncExecutor;

    private UserHttpService userHttpService;

    public void foo() {
      ...
      // 异步调用
      Future<User> userFuture = asyncExecutor.async(userHttpService::getById, id);

      ... 其他操作(如再发起http请求)
 
      // 获取结果
      User user = userFuture.get();
      ...
    }
}

对于原来的UserHttpService并不需要做任何修改,只要在需要的地方(A)指定为异步即可。

对于其他的无入参、两入参、无返回值等的方法形式,也可以类似处理:

public class AsyncExecutor {
      // 线程池,建议恰当配置和使用框架注入
      private ExecutorService executorService = Executors.newFixedThreadPool(10);
     
     /**
     * 无入参,无返回值的异步执行方法 , void noStaticFoo()
     *
     * @param method 要执行的方法,如 user::noStaticFoo;
     * @return Future对象,用以判断是否执行结束
     */
    public Future async(Runnable method) {
        return executorService.submit(method);
    }

    /**
     * 有单个入参,无返回值的异步执行方法,如 void noStaticFoo(Long id)
     *
     * @param method 要执行的方法,如, user::noStaticFoo
     * @param param  方法执行的入参,如id
     * @param <P>    入参类型,如Long
     * @return Future对象,用以判断是否执行结束
     */
    public <P> Future async(Consumer<P> method, P param) {
        return executorService.submit(() -> method.accept(param));
    }

    /**
     * 有两个参数但是无返回值的异步执行方法, 如void noStaticFoo(Long id,Entity entity)
     *
     * @param method 要执行的方法,如 , user::noStaticFoo
     * @param param1 第一个入参值,如id
     * @param param2 二个入参值,如entity
     * @param <P1>   第一个入参类型
     * @param <P2>   第二个入参类型
     * @return Future对象,用以判断是否执行结束
     */
    public <P1, P2> Future async(BiConsumer<P1, P2> method, P1 param1, P2 param2) {
        return executorService.submit(() -> method.accept(param1, param2));
    }

    /**
     * 无参数有返回值的异步执行方法 , Entity noStaticFoo()
     *
     * @param method 要执行的方法,如 , user::noStaticFoo
     * @param <R>    返回值类型,如 Entity
     * @return Future对象,用以判断是否执行结束、获取返回结果
     */
    public <R> Future<R> async(Supplier<R> method) {
        return executorService.submit(method::get);
    }

    /**
     * 单个入参,有返回值的异步执行方法 , Entity noStaticFoo(Long id)
     *
     * @param method 要执行的方法,如 , user::noStaticFoo
     * @param param  入参值,如 id
     * @param <P>    入参类型,如Long
     * @param <R>    返回值类型,如 Entity
     * @return Future对象,用以判断是否执行结束、获取返回结果
     */
    public <P, R> Future<R> async(Function<P, R> method, P param) {
        return executorService.submit(() -> method.apply(param));
    }

    /**
     * 单个入参,有返回值的异步执行方法 , Entity noStaticFoo(Long id)
     *
     * @param method 要执行的方法,如 , user::noStaticFoo
     * @param param1 第一个入参值,如id
     * @param param2 二个入参值,如entity
     * @param <P1>   第一个入参类型
     * @param <P2>   第二个入参类型
     * @param <R>    返回值类型,如 Entity
     * @return Future对象,用以判断是否执行结束、获取返回结果
     */
    public <P1, P2, R> Future<R> async(BiFunction<P1, P2, R> method, P1 param1, P2 param2) {
        return executorService.submit(() -> method.apply(param1, param2));
    }
}
上一篇下一篇

猜你喜欢

热点阅读