Lambda表达式源码解析

Function函数式接口

public class Test {
    public static void main(String[] args) {
        // B b = route("101", new Function<Integer, A>() {
        //     @Override
        //     public A apply(Integer integer) {
        //         A a = new A();
        //         String name = integer + "";
        //         a.setName(name);
        //         return a;
        //     }
        // });

        B b = route("101", (Integer integer) -> {
            A a = new A();
            String name = integer + "";
            a.setName(name);
            return a;
        });
        System.out.println(b);
    }

    public static B route(String token, Function<Integer, A> fn) {
        A a = fn.apply(new Integer(token));
        B b = new B();
        b.setName(a.getName() + "~");
        return b;
    }
}

class A {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "A{" +
                "name='" + name + '\'' +
                '}';
    }
}

class B {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "B{" +
                "name='" + name + '\'' +
                '}';
    }
}
/*
public RouteLocatorBuilder.Builder route(String id, Function<PredicateSpec, AsyncBuilder> fn) {
    AsyncBuilder routeBuilder = (AsyncBuilder)fn.apply((new RouteLocatorBuilder.RouteSpec(this)).id(id));
    this.add(routeBuilder);
    return this;
}

查看源码
(new RouteLocatorBuilder.RouteSpec(this)).id(id) 最终
return new PredicateSpec;   也就是模拟中的Integer类型-传入的类型
后面(AsyncBuilder)fn.apply(return new PredicateSpec;)将其转换成AsyncBuilder类型 也就是输出类型A
 */

Gateway路由配置类

package com.learn.cloud.config;

import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// Gateway路由配置类 - 完成和yml文件配置相同的功能
@Configuration
public class GatewayRoutesConfig {

    /*
    lambda表达式
     */
    @Bean
    public RouteLocator myRouteRouteLocator04(RouteLocatorBuilder routeLocatorBuilder){
        RouteLocatorBuilder.Builder routes = routeLocatorBuilder.routes();
        // route(String id, Function<PredicateSpec, AsyncBuilder> fn)
        // Function<PredicateSpec, AsyncBuilder> fn)是一个函数式接口
        // 接受的类型是PredicateSpec  返回的类型是AsyncBuilder> fn
        /*
        r -> r.path("/member/get/**")
                        .uri("http://localhost:10001")
        这个lambda表达式就是fn.apply()抽象方法的实现
        就是入参到出参的执行流程
        r就是PredicateSpec类型的入参
        public BooleanSpec path(String... patterns) {
            return this.asyncPredicate(((PathRoutePredicateFactory)this.getBean(PathRoutePredicateFactory.class)).applyAsync((c) -> {
                c.setPatterns(Arrays.asList(patterns));
            }));
        }
        c.setPatterns(Arrays.asList(patterns)); 设置patterns
        c.setPatterns(Arrays.asList("/member/get/**")); 设置patterns

        BooleanSpec extends UriSpec
        public class UriSpec {
            public AsyncBuilder uri(String uri) {
                return (AsyncBuilder)this.routeBuilder.uri(uri);
            }
        }
        这里就是设置uri this.routeBuilder.uri("http://localhost:10001")
        并且返回了AsyncBuilder即Function接口的出参类型
         */
        RouteLocator member_route04 = routes.route("member_route04",
                r -> r.path("/member/query/**")
                        .uri("http://localhost:10001"))
                .build();
        return member_route04;
    }
}