@Target(ElementType.PACKAGE)
@Retention(RetentionPolicy.RUNTIME)
public @interface PackageCheck {

    /**
     * 当前包的校验排除子包
     */
    String[] checkExcludeSubPackages() default "config";

    /**
     * 不能依赖此包的内容
     */
    String[] notAllowDependPackageNames();

    /**
     * 必须命名正则的规则
     */
    String mustNamePattern() default ".*";

    /**
     * 当前包所有的类必须继承的类
     */
    Class<?> classMustExtendClass() default Object.class;

    Class<?>[] exclusionClass() default {};

    /**
     * 当前包所有的类可以相互依赖
     */
    boolean interdependenceOnSamePackage() default true;

    /**
     * 当前包所有的类依赖的类型有且只能有一个(如果指定的话)
     */
    Class<?>[] dependOnly() default {};
}

@CodeVerify.PackageCheck(classMustExtendClass = BaseDAO.class
        , mustNamePattern = ".*Dao$"
        , notAllowDependPackageNames = {}// 如果dao的java代码可以引用service不报错，可以配置不能依赖service包。因为我们项目是分模块，如果用service代码编译器会直接报错，所以写不写都没有必要
        , interdependenceOnSamePackage = false) // 不允许有互相依赖，一个dao只能管理自己的表，如果涉及到其他表则应该放在service处理。

@Slf4j
public static class DependCheck implements ApplicationListener<ApplicationStartedEvent> {

   @SneakyThrows
   @Override
   public void onApplicationEvent(ApplicationStartedEvent event) {
      ConfigurableListableBeanFactory beanFactory = event.getApplicationContext().getBeanFactory();
      
      // 所有需要校验的包。Package.getPackages()只有对应的package有真正的类才算是真正的一个package，只有Package-info.java是不行的
      List<Package> checkPackageList = Arrays.stream(Package.getPackages())
              .filter(t -> t.isAnnotationPresent(PackageCheck.class))// 把需要校验的过滤出来
              .collect(Collectors.toList());

      String[] allBeanNames = beanFactory.getBeanDefinitionNames(); // 获取所有的bean

      List<String> errorMessageList = Lists.newArrayList();

      log.info("check PackageNames:{}", checkPackageList);
      for (Package checkPackage : checkPackageList) {
         PackageCheck annotation = checkPackage.getAnnotation(PackageCheck.class);
         log.info("DependCheck starting package:{}, configuration:{}", checkPackage.getName(), annotation);

         // 校验的条件
         String[] excludeSubPackages = annotation.checkExcludeSubPackages();
         Class<?> mustExtendClass = annotation.classMustExtendClass();
         String mustSuffixName = annotation.mustNamePattern();
         String[] notAllowDependPackageNames = annotation.notAllowDependPackageNames();
         boolean interdependenceOnSamePackage = annotation.interdependenceOnSamePackage();
         Class<?>[] dependOnly = annotation.dependOnly();
         Class<?>[] exclusionsClass = annotation.exclusionClass();


         String currentPackage = checkPackage.getName();
         for (String beanName : allBeanNames) {
            BeanDefinition mergedBeanDefinition = beanFactory.getMergedBeanDefinition(beanName);
            String beanClassName = mergedBeanDefinition.getResolvableType().getType().getTypeName();
            if (!beanClassName.startsWith(currentPackage)) { // 只有这个package的包才会校验
               continue;
            }

            boolean excludeSubPackage = Arrays.stream(excludeSubPackages)
                    .anyMatch(t -> beanClassName.substring(currentPackage.length()).contains(t)); // 排除子包的校验，如果有的话
            if (excludeSubPackage) {
               continue;
            }

            Class<?> beanClass = Class.forName(beanClassName);
            boolean exclusionClass = Arrays.stream(exclusionsClass) // 排除class的校验，如果有的话
                    .anyMatch(beanClass::isAssignableFrom);
            if (exclusionClass) {
               continue;
            }

            // 当前bean的依赖
            String[] beanDependenciesName = beanFactory.getDependenciesForBean(beanName);
            List<Class<?>> beanDependenciesClass = Arrays.stream(beanDependenciesName)
                    .map(beanFactory::getMergedBeanDefinition)
                    .map(BeanDefinition::getResolvableType)
                    .map(ResolvableType::getRawClass)
                    .collect(Collectors.toList());


            // 不允许依赖其他的包
            if (ArrayUtils.isNotEmpty(notAllowDependPackageNames)) {

               boolean match = Arrays.stream(notAllowDependPackageNames)
                       .anyMatch(notAllowDependPackageName ->
                               beanDependenciesClass.stream()
                                       .map(Class::getName)
                                       .anyMatch(className ->
                                               className.startsWith(notAllowDependPackageName)
                                       )
                       );

               if (match) {
                  String msg = MessageFormat.format(
                          "类:{0}，不能依赖{1}包的内容. \n\t目前依赖的有:{2}"
                          , beanClassName
                          , Arrays.toString(notAllowDependPackageNames)
                          , Arrays.toString(beanDependenciesName)
                  );
                  errorMessageList.add("依赖不规范:\n\t" + msg);
               }
            }

            // 不能有相互依赖
            if (!interdependenceOnSamePackage) {
               boolean match = beanDependenciesClass.stream()
                       .map(Class::getName)
                       .anyMatch(dependTypeName -> dependTypeName.startsWith(currentPackage));
               if (match) {
                  String msg = MessageFormat.format(
                          "类:{0}，不能依赖同包及子包的类. \n\t目前依赖的有:{1}"
                          , beanClassName
                          , Arrays.toString(beanDependenciesName)
                  );
                  errorMessageList.add("依赖不规范:\n\t" + msg);
               }
            }

            // 依赖的类型有且只能有一个
            if (ArrayUtils.isNotEmpty(dependOnly)) {

               boolean match = Arrays.stream(dependOnly)
                       .anyMatch(dependOnlyClass ->
                               beanDependenciesClass.stream()
                                       .filter(dependOnlyClass::isAssignableFrom)
                                       .count() > 1
                       );

               if (match) {
                  String msg = MessageFormat.format(
                          "类:{0}，依赖的类型有且只能有一个{1}, \n\t目前依赖的有:{2}"
                          , beanClassName
                          , Arrays.toString(dependOnly)
                          , Arrays.toString(beanDependenciesName)
                  );
                  errorMessageList.add("依赖不规范:\n\t" + msg);
               }
            }

            boolean configBean = beanClass.isAnnotationPresent(ConfigurationProperties.class) || beanClass.isAnnotationPresent(Component.class);

            if (!configBean && !mustExtendClass.isAssignableFrom(beanClass)) {
               errorMessageList.add("类继承不规范:\n\t" + beanClassName + "必须继承" + mustExtendClass);
            }
            if (!configBean && !beanClassName.matches(mustSuffixName)) {
               errorMessageList.add("名称不规范:\n\t" + beanClassName + "名称格式必须是:" + mustSuffixName);
            }

         }

      }
      if (!errorMessageList.isEmpty()) {
         throw new RuntimeException("代码编写不规范\n" + String.join("\n", errorMessageList)) {
            public Throwable fillInStackTrace() {
               return this;
            }
         };
      }
   }
}