org.swat.spring.SingletonVerifier Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of spring-mvc Show documentation
There is a newer version: 6.0.1
/*
 * Copyright © 2018 Swatantra Agrawal. All rights reserved.
 */

package org.swat.spring;

import org.reflections.Reflections;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RestController;

import java.io.File;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;


/**
 * The type Singleton verifier.
 */
public class SingletonVerifier {
  private static final Logger LOGGER = LoggerFactory.getLogger(SingletonVerifier.class);

  private final String[] basePackages;
  private final Comparator CLASS_THEN_NAME = new Comparator() {
    @Override
    public int compare(Field dis, Field dat) {
      int status = dis.getDeclaringClass().getName().compareTo(dat.getDeclaringClass().getName());
      if (status != 0) {
        return status;
      }
      return dis.getName().compareTo(dat.getName());
    }
  };

  /**
   * Instantiates a new Singleton verifier.
   *
   * @param basePackages the base backage
   */
  public SingletonVerifier(String... basePackages) {
    this.basePackages = basePackages;
  }

  /**
   * Annotations for Spring Bean
   *
   * @return the annotations
   */
  protected Collection> getAnnotations() {
    return new ArrayList<>(Arrays
        .asList(Component.class, Controller.class, Repository.class, Service.class, RestController.class));
  }

  /**
   * Fail on instance fields.
   */
  public void failOnInstanceFields() {
    final Set instanceFields = getInstanceFields();
    if (!instanceFields.isEmpty()) {
      System.out.println("=============================");
      System.out.println("Instance level fields are defined in a Singleton Object");
      int counter = 0;
      for (Field field : instanceFields) {
        System.out.println(++counter + "\t" + field);
      }
      System.out.println("=============================");
      System.out.println("Instance variables found in Singleton Objects. Check above logs.");
    }
    assert instanceFields.isEmpty();
  }

  /**
   * Gets instance fields.
   *
   * @return the instance fields
   */
  public Set getInstanceFields() {
    final Set instanceFields = new TreeSet<>(CLASS_THEN_NAME);
    Set> services = new HashSet<>();
    for (Class clazz : getAnnotations()) {
      for (String basePackage : basePackages) {
        services.addAll(new Reflections(basePackage).getTypesAnnotatedWith(clazz));
      }
    }
    for (Class service : services) {
      instanceFields.addAll(getInstanceFields(service));
    }
    return instanceFields;
  }

  /**
   * Is test class boolean.
   *
   * @param service the service
   * @return the boolean
   */
  public static boolean isTestClass(Class service) {
    File file = new File(".");
    String fileName = service.getName();
    return isTestClass(file, fileName, 2);
  }

  /**
   * Is test class boolean.
   *
   * @param folder   the folder
   * @param fileName the file name
   * @param depth    the depth
   * @return the boolean
   */
  public static boolean isTestClass(File folder, String fileName, int depth) {
    if (depth < 0) {
      return false;
    }
    if (!folder.isDirectory()) {
      return false;
    }
    if (new File(folder, fileName).exists()) {
      return true;
    }
    File[] files = folder.listFiles();
    if (files == null) {
      return false;
    }
    for (File file : files) {
      if (isTestClass(file, fileName, depth - 1)) {
        return true;
      }
    }
    return false;
  }

  /**
   * Populate fields.
   *
   * @param clazz  the clazz
   * @param fields the fields
   */
  public static void populateFields(Class clazz, Set fields) {
    if (clazz == null || clazz == Object.class) {
      return;
    }
    Field[] declaredFields = clazz.getDeclaredFields();
    if (declaredFields != null) {
      Collections.addAll(fields, declaredFields);
    }
    populateFields(clazz.getSuperclass(), fields);
  }

  /**
   * Is service interface boolean.
   *
   * @param basePackages the base packages
   * @param type         the type
   * @return the boolean
   */
  public static boolean isServiceInterface(String[] basePackages, Class type) {
    if (isTestClass(type)) {
      return true;
    }
    final Set> allSubTypes = new HashSet<>();
    for (String basePackage : basePackages) {
      Collection> subTypes = new Reflections(basePackage).getSubTypesOf(type);
      if (subTypes != null) {
        allSubTypes.addAll(subTypes);
      }
    }
    Iterator> iterator = allSubTypes.iterator();
    while (iterator.hasNext()) {
      if (isTestClass(iterator.next())) {
        iterator.remove();
      }
    }
    return allSubTypes.size() == 1;
  }

  /**
   * Gets instance fields.
   *
   * @param service the service
   * @return the instance fields
   */
  public Set getInstanceFields(Class service) {
    final Set instanceFields = new TreeSet<>(CLASS_THEN_NAME);
    try {
      if (isTestClass(service)) {
        return instanceFields;
      }
      Scope scope = service.getAnnotation(Scope.class);
      if (scope != null && !scope.scopeName().equalsIgnoreCase(ConfigurableBeanFactory.SCOPE_SINGLETON)) {
        return instanceFields;
      }
      Set allFields = new HashSet<>();
      populateFields(service, allFields);
      for (Field field : allFields) {
        if (Modifier.isFinal(field.getModifiers())) {
          continue;
        }
        if (field.isAnnotationPresent(IgnoredInstance.class)) {
          continue;
        }
        if (field.isAnnotationPresent(Autowired.class)) {
          continue;
        }
        if (field.isAnnotationPresent(Value.class)) {
          continue;
        }
        if (isServiceInterface(basePackages, field.getType())) {
          continue;
        }
        if (isJacocoField(field)) {
          continue;
        }
        if (!isInstance(field)) {
          continue;
        }
        instanceFields.add(field);
      }
    } catch (Throwable e) {
      LOGGER.warn("Exception in service class[{}] - {}", service, e.getMessage());
    }
    return instanceFields;
  }

  private boolean isJacocoField(Field field) {
    final int modifiers = field.getModifiers();
    if (!Modifier.isStatic(modifiers)) {
      return false;
    }
    if (!Modifier.isTransient(modifiers)) {
      return false;
    }
    if (!Modifier.isPrivate(modifiers)) {
      return false;
    }
    if (!field.getName().equalsIgnoreCase("$jacocoData")) {
      return false;
    }
    if (field.getType() != boolean[].class) {
      return false;
    }
    return true;
  }

  /**
   * Hook to add more validations.
   *
   * @param field the field
   * @return the boolean
   */
  protected boolean isInstance(Field field) {
    return true;
  }
}