Java动手封装一个模仿Switch的工具

目的

使用这个工具可以实现switch逻辑，case支持断言函数 。替换掉 大量的else if 或者 switch

java code

import java.util.LinkedList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * Switch.of("this is data or lambda")
 * .when(lambda predicate) true or false
 * .todo(lambda consumer) run
 * .when(lambda predicate) true or false
 * .todo(lambda consumer) run
 * .defaultTodo(x -> System.out.println("未匹配到"))
 * .done(); //  must ,this function is real match invoke
 * <p>
 * 一个数据源或者一个可以返回数据源的函数，根据不同的断言条件匹配不同的消费函数
 * 无匹配项则执行默认的函数，类似于switch . 替换 == 为 函数式断言条件
 * done(); //  must ,this function is real match invoke
 * </p>
 * 使用这个工具可以实现switch逻辑，case支持断言函数 。替换掉 大量的else if 或者 switch
 */
public class Switch<T> {

    private T data;
    private List<CaseInvoke<T>> caseInvokes = new LinkedList<>();

    private Switch(T data) {
        this.data = data;
    }

    public void appendCaseInvoke(CaseInvoke<T> caseInvoke) {
        caseInvokes.add(caseInvoke);
    }

    public void done() {
        Consumer<T> consumer = caseInvokes.stream().filter(x -> x
            .isDefaultInvoke())
            .findFirst()
            .map(CaseInvoke::getConsumer).get();

        if (data == null) {
            consumer.accept(data);
        }
        boolean match = false;

        List<CaseInvoke<T>> invokes = caseInvokes.stream().filter(x -> !x.isDefaultInvoke())
            .collect(Collectors.toList());

        for (CaseInvoke<T> caseInvoke : invokes) {
            if (caseInvoke.getPredicate().test(data)) {
                caseInvoke.getConsumer().accept(data);
                match = true;
            }
        }

        if (!match) {
            consumer.accept(data);
        }
    }

    public static <T> CaseInvokerPredicateSetter<T> of(T data) {
        Switch<T> tSwitch = new Switch<>(data);
        return new CaseInvokerPredicateSetter<T>(tSwitch);
    }

    public static <T> CaseInvokerPredicateSetter<T> of(Supplier<T> tSupplier) {
        Switch<T> tSwitch = new Switch<>(tSupplier.get());
        return new CaseInvokerPredicateSetter<T>(tSwitch);
    }


    public static class CaseInvokerPredicateSetter<T> {
        private Switch<T> tSwitch;
        private CaseInvoke<T> caseInvoke;


        public CaseInvokerPredicateSetter(Switch<T> tSwitch) {
            this.tSwitch = tSwitch;
            this.caseInvoke = new CaseInvoke<>();
        }


        public CaseInvokerConsumerSetter<T> when(Predicate<T> predicate) {
            this.caseInvoke = new CaseInvoke<>();
            this.caseInvoke.setPredicate(predicate);
            return new CaseInvokerConsumerSetter<>(tSwitch, caseInvoke);
        }


        public Switch<T> defaultTodo(Consumer<T> consumer) {
            CaseInvoke<T> caseInvoke = new CaseInvoke<>();
            caseInvoke.setConsumer(consumer);
            caseInvoke.setDefaultInvoke(true);
            tSwitch.appendCaseInvoke(caseInvoke);
            return tSwitch;
        }
    }


    public static class CaseInvokerConsumerSetter<T> {
        private Switch<T> tSwitch;
        private CaseInvoke<T> caseInvoke;

        public CaseInvokerConsumerSetter(Switch<T> tSwitch, CaseInvoke<T> caseInvoke) {
            this.tSwitch = tSwitch;
            this.caseInvoke = caseInvoke;
        }


        public CaseInvokerPredicateSetter<T> todo(Consumer<T> consumer) {
            caseInvoke.setConsumer(consumer);
            caseInvoke.setDefaultInvoke(false);
            tSwitch.appendCaseInvoke(caseInvoke);
            return new CaseInvokerPredicateSetter<>(tSwitch);
        }


    }


    public static class CaseInvoke<T> {
        private Predicate<T> predicate;
        private Consumer<T> consumer;
        private boolean defaultInvoke;

        public CaseInvoke() {
        }

        public CaseInvoke(Predicate<T> predicate, Consumer<T> consumer) {
            this.predicate = predicate;
            this.consumer = consumer;
        }

        public CaseInvoke(Predicate<T> predicate, Consumer<T> consumer, boolean defaultInvoke) {
            this.predicate = predicate;
            this.consumer = consumer;
            this.defaultInvoke = defaultInvoke;
        }

        public Predicate<T> getPredicate() {
            return predicate;
        }

        public void setPredicate(Predicate<T> predicate) {
            this.predicate = predicate;
        }

        public Consumer<T> getConsumer() {
            return consumer;
        }

        public void setConsumer(Consumer<T> consumer) {
            this.consumer = consumer;
        }

        public boolean isDefaultInvoke() {
            return defaultInvoke;
        }

        public void setDefaultInvoke(boolean defaultInvoke) {
            this.defaultInvoke = defaultInvoke;
        }
    }


    public static void main(String[] args) {

        /**
         * 之前的写法
         */
        switch ("A") {
            case "A":
                System.out.println("A");
                break;
            case "B":
                System.out.println("B");
                break;
            default:
                System.out.println("default");
        }

        /**
         * 现在的写法
         */
        Switch.of("D")
            .when(x -> x.equals("A"))
            .todo(x -> System.out.println("A"))
            .when(x -> x.equals("B"))
            .todo(x -> System.out.println("B"))
            .defaultTodo(x -> System.out.println("未匹配到"))
            .done();

        /**
         * 另外一种书面格式
         */
        Switch.of("D")
            .when(x -> {
                return x.equals("A");
            })
            .todo(x -> {
                System.out.println("A");
            })
            .when(x -> {
                return x.equals("B");
            })
            .todo(x -> {
                System.out.println("B");
            })
            .defaultTodo(x -> {
                System.out.println("未匹配到");
            })
            .done();

        /**
         *demo
         */

        Switch.of(() -> new User("jack"))
            .when(x -> x.getName().equals("jack"))
            .todo(x -> System.out.println("user name is jack"))
            .when(x -> x.getName().equals("tom"))
            .todo(x -> System.out.println("user name is tom"))
            .defaultTodo(x -> System.out.println("Who is he?"))
            .done();

    }

    @Data
    @AllArgsConstructor

    public static class User {
        private String name;

    }
}