class DtpInterceptorRegistry {

    /**
     * Maintain all automatically registered and manually registered INTERCEPTORS
     */
    private static final Map<String, DtpInterceptor> INTERCEPTORS = Maps.newConcurrentMap();

    static {
        List<DtpInterceptor> loadedInterceptors = ExtensionServiceLoader.get(DtpInterceptor.class);
        if (CollectionUtils.isNotEmpty(loadedInterceptors)) {
            loadedInterceptors.forEach(x -> {
                DtpIntercepts interceptsAnno = x.getClass().getAnnotation(DtpIntercepts.class);
                if (Objects.nonNull(interceptsAnno)) {
                    String name = StringUtils.isBlank(interceptsAnno.name()) ? x.getClass().getSimpleName() : interceptsAnno.name();
                    INTERCEPTORS.put(name, x);
                }
            });
        }
    }

    private DtpInterceptorRegistry() { }

    public static void register(String name, DtpInterceptor dtpInterceptor) {
        log.info("DynamicTp register DtpInterceptor, name: {}, interceptor: {}", name, dtpInterceptor);
        INTERCEPTORS.put(name, dtpInterceptor);
    }

    public static Map<String, DtpInterceptor> getInterceptors() {
        return Collections.unmodifiableMap(INTERCEPTORS);
    }

    public static Object pluginAll(Object target) {
        return plugin(target, INTERCEPTORS.keySet());
    }

    public static Object pluginAll(Object target, Class<?>[] argTypes, Object[] args) {
        return plugin(target, INTERCEPTORS.keySet(), argTypes, args);
    }

    public static Object plugin(Object target, Set<String> interceptors) {<FILL_FUNCTION_BODY>}

    public static Object plugin(Object target, Set<String> interceptors, Class<?>[] argTypes, Object[] args) {
        val filterInterceptors = getInterceptors(interceptors);
        for (DtpInterceptor interceptor : filterInterceptors) {
            target = interceptor.plugin(target, argTypes, args);
        }
        return target;
    }

    private static Collection<DtpInterceptor> getInterceptors(Set<String> interceptors) {
        if (CollectionUtils.isEmpty(interceptors)) {
            return INTERCEPTORS.values();
        }
        return INTERCEPTORS.entrySet()
                .stream()
                .filter(x -> StringUtil.containsIgnoreCase(x.getKey(), interceptors))
                .map(Map.Entry::getValue)
                .collect(toList());
    }
}

        val filterInterceptors = getInterceptors(interceptors);
        for (DtpInterceptor interceptor : filterInterceptors) {
            target = interceptor.plugin(target);
        }
        return target;
    
<no_super_class>