java程序提供默认实现策略，并支持自定义实现策略的一种方式？并如何避雷？

java程序提供默认实现策略，并支持自定义实现策略的一种方式？并如何避雷？

方案？

说明：

当前是基于自定义策略注册由工具类提供，且默认实现策略全局可访问的前提下进行探讨，其他场景也可进行参考，如有问题欢迎指出学习。

方案一： 在默认策略的实现中直接判断当前是否有注册了自定义策略，如果存在则以自定义策略实现为准去调用。（不推荐使用，存在严重问题）—见test1方法。

调用方式：在程序中调用是通过判断自定义策略是否存在，存在时使用自定义策略调用，反之使用默认策略调用。（其实也可直接用默认策略调用）

分析：如果用户在自定义实现中继承默认实现策略类并进行了调用父类方法（即默认策略实现）或特殊分支情况下使用默认策略实现，则会出现双方互相调用的死循环问题。 （除非进行了明确规范和要求并严格检查才不会出现该问题？）

方案二： 在默认实现中只关心当前的实现逻辑，不关心自定义策略的调用。（推荐使用）—见test2方法。

调用方式：在程序中调用是通过判断自定义策略是否存在，存在时使用自定义策略调用，反之使用默认策略调用。

分析：无论用户在自定义实现中继承默认实现策略类并进行了调用父类方法（即默认策略实现）或特殊分支情况下使用默认策略实现，都不会出现双方互相调用的死循环问题。并且支持用户在某些特定场景情况下自行实现，其他则使用默认策略实现。

代码示例

public class Test {


    interface Callback {
        boolean isTrue(String text);
    }

    static void test1() {
        Callback defaultCallback = new Callback() {
            @Override
            public boolean isTrue(String text) {

                if (InnerUtils.getCustomCallback() != null) {
                    return InnerUtils.getCustomCallback().isTrue(text);
                }

                return false;
            }
        };

        Callback customCallback = new Callback() {
            @Override
            public boolean isTrue(String text) {
                if ("A".equals(text)) {
                    return InnerUtils.getDefaultCallback().isTrue(text);
                }
                return true;
            }
        };

        InnerUtils.setDefaultCallback(defaultCallback);
        InnerUtils.setCustomCallback(customCallback);

        Callback useCallback = customCallback != null ? customCallback : defaultCallback;
        System.out.println(useCallback.isTrue("B")); // 自定义的自身实现  true
        System.out.println(useCallback.isTrue("C")); // 自定义的自身实现 true
        System.out.println(useCallback.isTrue("A")); // 特殊分支，进行调用默认的实现，默认实现中又调用自定义的实现导致死循环 ?? --- StackOverflowError

    }


    static void test2() {

        class DefaultCallback implements Callback {

            @Override
            public boolean isTrue(String text) {
                return false;
            }
        }

        class CustomCallback extends DefaultCallback implements Callback {

            @Override
            public boolean isTrue(String text) {
                if ("A".equals(text)) {
                    return InnerUtils.getDefaultCallback().isTrue(text);
                }

                if ("B".equals(text)) {
                    return super.isTrue(text);
                }

                return true;
            }
        }


        Callback defaultCallback = new DefaultCallback();
        Callback customCallback = new CustomCallback();

        InnerUtils.setDefaultCallback(defaultCallback);
        InnerUtils.setCustomCallback(customCallback);

        Callback useCallback = customCallback != null ? customCallback : defaultCallback;

        System.out.println(useCallback.isTrue("B")); // 特殊分支，进行调用super.isTrue -- 默认的实现 false
        System.out.println(useCallback.isTrue("C")); // 自定义的自身实现 --  true
        System.out.println(useCallback.isTrue("A")); // 特殊分支，进行调用defaultCallback.isTrue -- 默认的实现 false

    }

    public static void main(String[] args) {

        System.out.println("------------");
        System.out.println("----test1执行开始---");

        try {
            test1();
        } catch (Exception | Error e) {
            System.out.println("test1存在异常: " + e);
        }
        System.out.println("----test1执行结束---");

        System.out.println();

        System.out.println("------------");
        System.out.println("----test2执行开始---");

        test2();
        System.out.println("----test2执行结束---");

        System.out.println("------------");


    }

    static class InnerUtils {

        static Callback defaultCallback;
        static Callback customCallback;

        public static Callback getDefaultCallback() {
            return defaultCallback;
        }

        public static void setDefaultCallback(Callback defaultCallback) {
            InnerUtils.defaultCallback = defaultCallback;
        }

        public static Callback getCustomCallback() {
            return customCallback;
        }

        public static void setCustomCallback(Callback customCallback) {
            InnerUtils.customCallback = customCallback;
        }
    }
}

执行结果

------------
----test1执行开始---
true
true
test1存在异常: java.lang.StackOverflowError
----test1执行结束---

------------
----test2执行开始---
false
true
false
----test2执行结束---
------------