Crjvm205

java-plugin/src/main/java/fr/greencodeinitiative/java/RulesList.java

@@ -24,25 +24,7 @@
 import java.util.Collections;
 import java.util.List;
 
-import fr.greencodeinitiative.java.checks.ArrayCopyCheck;
-import fr.greencodeinitiative.java.checks.AvoidConcatenateStringsInLoop;
-import fr.greencodeinitiative.java.checks.AvoidFullSQLRequest;
-import fr.greencodeinitiative.java.checks.AvoidGettingSizeCollectionInLoop;
-import fr.greencodeinitiative.java.checks.AvoidMultipleIfElseStatement;
-import fr.greencodeinitiative.java.checks.AvoidRegexPatternNotStatic;
-import fr.greencodeinitiative.java.checks.AvoidSQLRequestInLoop;
-import fr.greencodeinitiative.java.checks.AvoidSetConstantInBatchUpdate;
-import fr.greencodeinitiative.java.checks.AvoidSpringRepositoryCallInLoopCheck;
-import fr.greencodeinitiative.java.checks.AvoidStatementForDMLQueries;
-import fr.greencodeinitiative.java.checks.AvoidUsageOfStaticCollections;
-import fr.greencodeinitiative.java.checks.AvoidUsingGlobalVariablesCheck;
-import fr.greencodeinitiative.java.checks.FreeResourcesOfAutoCloseableInterface;
-import fr.greencodeinitiative.java.checks.IncrementCheck;
-import fr.greencodeinitiative.java.checks.InitializeBufferWithAppropriateSize;
-import fr.greencodeinitiative.java.checks.NoFunctionCallWhenDeclaringForLoop;
-import fr.greencodeinitiative.java.checks.OptimizeReadFileExceptions;
-import fr.greencodeinitiative.java.checks.UnnecessarilyAssignValuesToVariables;
-import fr.greencodeinitiative.java.checks.UseCorrectForLoop;
+import fr.greencodeinitiative.java.checks.*;
 import org.sonar.plugins.java.api.JavaCheck;
 
 public final class RulesList {
@@ -77,7 +59,8 @@ public static List<Class<? extends JavaCheck>> getJavaChecks() {
                 AvoidUsingGlobalVariablesCheck.class,
                 AvoidSetConstantInBatchUpdate.class,
                 FreeResourcesOfAutoCloseableInterface.class,
-                AvoidMultipleIfElseStatement.class
+                AvoidMultipleIfElseStatement.class,
+                ForceUsingLazyFetchTypeInJPAEntity.class
         ));
     }
 

java-plugin/src/main/java/fr/greencodeinitiative/java/checks/ForceUsingLazyFetchTypeInJPAEntity.java

@@ -0,0 +1,93 @@
+package fr.greencodeinitiative.java.checks;
+
+import org.sonar.check.Priority;
+import org.sonar.check.Rule;
+import org.sonar.plugins.java.api.IssuableSubscriptionVisitor;
+import org.sonar.plugins.java.api.tree.*;
+import org.sonar.plugins.java.api.tree.Tree.Kind;
+
+import java.util.List;
+
+@Rule(key = "EC80", name = "Developpement",
+        description = ForceUsingLazyFetchTypeInJPAEntity.MESSAGERULE,
+        priority = Priority.MINOR,
+        tags = {"bug"})
+public class ForceUsingLazyFetchTypeInJPAEntity extends IssuableSubscriptionVisitor {
+
+    protected static final String MESSAGERULE = "Force the use of LAZY FetchType";
+    private static final String EAGER_KEYWORD = "EAGER";
+    private static final String FETCH_KEYWORD = "fetch";
+    private static final String ONE_TO_MANY = "OneToMany";
+    private static final String MANY_TO_ONE = "ManyToOne";
+    private static final String ONE_TO_ONE = "OneToOne";
+    private static final String MANY_TO_MANY = "ManyToMany";
+
+    @Override
+    public List<Kind> nodesToVisit() {
+        return List.of(Kind.VARIABLE);
+    }
+
+    @Override
+    public void visitNode(Tree tree) {
+        VariableTree variableTree = (VariableTree) tree;
+        List<AnnotationTree> annotations = variableTree.modifiers().annotations();
+        // get all annotations on the attribute
+        for (AnnotationTree annotationTree : annotations) {
+            if (!needToCheckExplicitAnnotation(annotationTree.annotationType().symbolType().name())) {
+                // no Explicit annotation (@OneToMany, @ManyToOne, @ManyToMany, @OneToOne) was found,
+                // and we don't need to investigate further
+                continue;
+            }
+            Arguments arguments = annotationTree.arguments();
+            performsCheck(arguments, annotationTree, tree);
+        }
+    }
+
+    /**
+     * perform the check for two case :
+     * fetch keyword is found -> parse the annotation argument and search for eager keyword
+     * fetch keyword was not found -> we use the default value of fetch type by join type :
+     * OneToMany: Lazy
+     * ManyToOne: Eager
+     * ManyToMany: Lazy
+     * OneToOne: Eager
+     * reporting the issues if necessary
+     */
+    private void performsCheck(Arguments arguments, AnnotationTree annotationTree, Tree tree) {
+        boolean fetchFound = false;
+        for (ExpressionTree argument : arguments) {
+            AssignmentExpressionTree assignmentExpression = (AssignmentExpressionTree) argument;
+            IdentifierTree variable = (IdentifierTree) assignmentExpression.variable();
+
+            if (!FETCH_KEYWORD.equals(variable.name())) {
+                // no need to continue checking this argument
+                continue;
+            }
+            String fetchValue = ((MemberSelectExpressionTree) assignmentExpression.expression()).identifier().name();
+            fetchFound = true;
+            if (EAGER_KEYWORD.equals(fetchValue)) {
+                reportIssue(tree, MESSAGERULE);
+            }
+        }
+        //- The default case of the ManyToOne and the OneToOne
+        // the fetch keyword is not explicit
+        if (fetchFound) {
+            return;
+        }
+        String symbolType = annotationTree.annotationType().symbolType().name();
+        if ((MANY_TO_ONE.equals(symbolType) || ONE_TO_ONE.equals(symbolType))) {
+            reportIssue(tree, MESSAGERULE);
+        }
+    }
+
+    /**
+     * @param symbolType the annotation type name : @OneToMany, @ManyToOne...
+     * @return true if searched annotation was found and checks need to be performed
+     */
+    private boolean needToCheckExplicitAnnotation(String symbolType) {
+        return ONE_TO_MANY.equals(symbolType)
+                || MANY_TO_ONE.equals(symbolType)
+                || ONE_TO_ONE.equals(symbolType)
+                || MANY_TO_MANY.equals(symbolType);
+    }
+}

java-plugin/src/main/resources/fr/greencodeinitiative/l10n/java/rules/java/EC80.html

@@ -0,0 +1,30 @@
+<p>Consider using LAZY mode on your FetchType for collections in JPA type entities. This will reduce the amount of data loaded into memory.</p>
+
+<h2>Non-compliant Code Example</h2>
+<pre>
+    @Entity
+    @Table(name = "purchaseOrder")
+    public class Order implements Serializable {
+
+      @OneToMany(mappedBy = "order", fetch = FetchType.EAGER)
+      private Set<OrderItem> items = new HashSet<OrderItem>();
+
+      ...
+
+    }
+
+</pre>
+<h2>Compliant Code Example</h2>
+<pre>
+    @Entity
+    @Table(name = "purchaseOrder")
+    public class Order implements Serializable {
+
+      @OneToMany(mappedBy = "order", fetch = FetchType.LAZY)
+      private Set<OrderItem> items = new HashSet<OrderItem>();
+
+      ...
+
+    }
+
+</pre>

java-plugin/src/main/resources/fr/greencodeinitiative/l10n/java/rules/java/EC80.json

@@ -0,0 +1,16 @@
+{
+    "title": "Force the use of FetchType LAZY on collections in Entity JPA",
+    "type": "CODE_SMELL",
+    "status": "ready",
+    "remediation": {
+      "func": "Constant\/Issue",
+      "constantCost": "5min"
+    },
+    "tags": [
+      "eco-design",
+      "performance",
+      "bug",
+      "ecocode"
+    ],
+    "defaultSeverity": "Minor"
+  }

java-plugin/src/test/files/ForceLazyFetchTypeUseAllInOne.java

@@ -0,0 +1,26 @@
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+import javax.persistence.Transient;
+
+@Entity
+@Table(name = "myTable")
+public class ForceLazyFetchTypeUseAllInOne implements Serializable {
+
+  @OneToMany(mappedBy = "myOrders", fetch = FetchType.EAGER) // Noncompliant {{Force the use of LAZY FetchType}}
+  private Set<OrderItem> items = new HashSet<OrderItem>();
+
+  @OneToMany(mappedBy = "myOrders", fetch = FetchType.LAZY)
+  private Set<OrderItem> items = new HashSet<OrderItem>();
+
+  @Column(name = "ORDER", length = 50, nullable = false, unique = false)
+  private Set<OrderItem> items = new HashSet<OrderItem>();
+
+}

java-plugin/src/test/files/ForceLazyFetchTypeUseCompliant.java

@@ -0,0 +1,20 @@
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+import javax.persistence.Transient;
+
+@Entity
+@Table(name = "myTable")
+public class ForceLazyFetchTypeUseCompliant implements Serializable {
+
+  @OneToMany(mappedBy = "myOrders", fetch = FetchType.LAZY)
+  private Set<OrderItem> items = new HashSet<OrderItem>();
+
+}

java-plugin/src/test/files/ForceLazyFetchTypeUseDefaultManyToOne.java

@@ -0,0 +1,20 @@
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+import javax.persistence.Transient;
+
+@Entity
+@Table(name = "myTable")
+public class ForceLazyFetchTypeUseFalse implements Serializable {
+
+    @ManyToOne // Noncompliant {{Force the use of LAZY FetchType}}
+    private Order order;
+
+}

java-plugin/src/test/files/ForceLazyFetchTypeUseDefaultOneToOne.java

@@ -0,0 +1,20 @@
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+import javax.persistence.Transient;
+
+@Entity
+@Table(name = "myTable")
+public class ForceLazyFetchTypeUseFalse implements Serializable {
+
+    @OneToOne // Noncompliant {{Force the use of LAZY FetchType}}
+    private OrderInformation orderInformations;
+
+}

java-plugin/src/test/files/ForceLazyFetchTypeUseFalseTest.java

@@ -0,0 +1,20 @@
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+import javax.persistence.Transient;
+
+@Entity
+@Table(name = "myTable")
+public class ForceLazyFetchTypeUseFalseTest implements Serializable {
+
+  @Column(name = "ORDER", length = 50, nullable = false, unique = false)
+  private Set<OrderItem> items = new HashSet<OrderItem>();
+
+}

java-plugin/src/test/files/ForceLazyFetchTypeUseManyToOne.java

@@ -0,0 +1,20 @@
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+import javax.persistence.Transient;
+
+@Entity
+@Table(name = "myTable")
+public class ForceLazyFetchTypeUseFalseTest implements Serializable {
+
+  @ManyToOne(fetch = FetchType.EAGER)  // Noncompliant {{Force the use of LAZY FetchType}}
+  private Order order;
+
+}

java-plugin/src/test/files/ForceLazyFetchTypeUseNonCompliant.java

@@ -0,0 +1,20 @@
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+import javax.persistence.Transient;
+
+@Entity
+@Table(name = "myTable")
+public class ForceLazyFetchTypeUseNonCompliant implements Serializable {
+
+  @OneToMany(mappedBy = "myOrders", fetch = FetchType.EAGER) // Noncompliant {{Force the use of LAZY FetchType}}
+  private Set<OrderItem> items = new HashSet<OrderItem>();
+
+}

java-plugin/src/test/files/ForceLazyFetchTypeUseOneToOne.java

@@ -0,0 +1,20 @@
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.persistence.Temporal;
+import javax.persistence.TemporalType;
+import javax.persistence.Transient;
+
+@Entity
+@Table(name = "myTable")
+public class ForceLazyFetchTypeUseFalseTest implements Serializable {
+
+  @OneToOne(fetch = FetchType.EAGER) // Noncompliant {{Force the use of LAZY FetchType}}
+  private OrderInformation orderInformations;
+
+}

java-plugin/src/test/java/fr/greencodeinitiative/java/JavaCheckRegistrarTest.java

@@ -32,7 +32,7 @@ void checkNumberRules() {
         final JavaCheckRegistrar registrar = new JavaCheckRegistrar();
         registrar.register(context);
 
-        assertThat(context.checkClasses()).hasSize(19);
+        assertThat(context.checkClasses()).hasSize(20);
         assertThat(context.testCheckClasses()).isEmpty();
     }
 }