import lombok.extern.slf4j.Slf4j;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.util.ClassUtils;

import java.io.IOException;
import java.util.HashSet;
import java.util.Set;

@Slf4j
public class ClassUtil {

    /**
     * 由于spring boot 打包為jar包，jersey packages 無法掃描jar對應的文件夾的文件，故自定義包掃描
     *
     * @return class[]
     */
    public static Set<Class<?>> findAllClasses(String... scanPackages) {
        Set<Class<?>> classes = new HashSet<>();
        for (String scanPackage : scanPackages) {
            ClassLoader loader = ClassUtil.class.getClassLoader();
            Resource[] resources = new Resource[0];
            try {
                resources = scan(loader, scanPackage);
            } catch (IOException e) {
                log.error("加載class異常", e);
            }
            classes.addAll(convert(loader, resources));
        }
        return classes;
    }

    /**
     * 掃描 jar 包
     *
     * @param loader      ClassLoader
     * @param packageName packageName
     */
    private static Resource[] scan(ClassLoader loader, String packageName) throws IOException {
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(loader);
        String pattern = "classpath*:" + ClassUtils.convertClassNameToResourcePath(packageName) + "/*.class";
        return resolver.getResources(pattern);
    }

    /**
     * 加載 class
     *
     * @param loader   ClassLoader
     * @param resource resource
     */
    private static Class<?> loadClass(ClassLoader loader, Resource resource) {
        try {
            CachingMetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(loader);
            MetadataReader reader = metadataReaderFactory.getMetadataReader(resource);
            return ClassUtils.forName(reader.getClassMetadata().getClassName(), loader);
        } catch (LinkageError | ClassNotFoundException e) {
            if (log.isDebugEnabled()) {
                log.debug("Ignoring candidate class resource " + resource + " due to " + e);
            }
            return null;
        } catch (Throwable e) {
            if (log.isWarnEnabled()) {
                log.warn("Unexpected failure when loading class resource " + resource, e);
            }
            return null;
        }
    }

    /**
     * resources 轉換為 Set<Class>
     *
     * @param loader    ClassLoader
     * @param resources Resource
     */
    private static Set<Class<?>> convert(ClassLoader loader, Resource[] resources) {
        Set<Class<?>> classSet = new HashSet<>(resources.length);
        for (Resource resource : resources) {
            Class<?> clazz = loadClass(loader, resource);
            if (clazz != null) {
                classSet.add(clazz);
            }
        }
        return classSet;
    }

}

@Configuration
public class JerseyConfig extends ResourceConfig {

    public JerseyConfig() {
        // 注冊包掃描 這個方法在開發(fā)使用沒問題，但是打包jar后，找不到 class 文件
//        packages("com.xxx.xxx.api");

        // 定義掃描包含接口資源包
        registerClasses(ClassUtil.findAllClasses("com.xxx.xxx.api"));
    }
}

public class JerseyServiceAutoScanner {
    private JerseyServiceAutoScanner() {}

    public static Class[] getPublishJerseyServiceClasses(ApplicationContext context, String... scanPackages) {
        // 傳入applicationContext對象，在整個spring容器中撈我們需要的controller
        // 傳入的第二個參數是可變參數，字符串，用于傳入需要掃描的包路徑
        List<Class> jerseyServiceClasses = new ArrayList<>();
        if (scanPackages == null || scanPackages.length == 0) {
            return jerseyServiceClasses.toArray(new Class[jerseyServiceClasses.size()]);
        }
        ClassPathScanningCandidateComponentProvider scanner = new JerseyScanningComponentProvider(false);
        // 我只需要掃描使用了@Path注解的controller，如果還有其他的組合條件，可以在這里增加
        scanner.addIncludeFilter(new AnnotationTypeFilter(Path.class));
        for (var scanPackage : scanPackages) {
            jerseyServiceClasses.addAll(scanner.findCandidateComponents(scanPackage).stream()
                    .map(beanDefinition -> ClassUtils
                            .resolveClassName(beanDefinition.getBeanClassName(), applicationContext.getClassLoader()))
                    .collect(Collectors.toSet()));
        }
        // 返回符合條件的spring容器中的全部的類對象
        return jerseyServiceClasses.toArray(new Class[jerseyServiceClasses.size()]);
    }

    private static class JerseyScanningComponentProvider extends ClassPathScanningCandidateComponentProvider {
        public JerseyScanningComponentProvider(boolean useDefaultFilters) {
            super(useDefaultFilters);
        }
        @Override
        protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
            AnnotationMetadata metadata = beanDefinition.getMetadata();
            // 注意這里的值，最好debug一下，我使用的時候，只有第一個metadata.isIndependent()是true
            return (metadata.isIndependent() && metadata.isAbstract() && !beanDefinition.getMetadata().isAnnotation());
        }
    }
}

@Configuration
public class JerseyConfig extends ResourceConfig implements ApplicationContextAware {

    private ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @PostConstruct
    public void init() {
        registerClasses(JerseyServiceAutoScanner.getPublishJerseyServiceClasses(applicationContext, "com.xxx.xxx.api"));
    }
    public JerseyConfig() {
    // 。。。 其他的 。。。
    }
}