[feature][connector-mock] Mock Source Type 添加Eval类型，用于支持计算列

6 files changed, 116 insertions, 9 deletions

diff --git a/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/ArrayFaker.java b/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/ArrayFaker.java
index c6bb9bd..f807ecb 100644
--- a/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/ArrayFaker.java
+++ b/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/ArrayFaker.java
@@ -17,7 +17,7 @@ public class ArrayFaker extends Faker<List<Object>> {
     }

 

     public ArrayFaker(Faker<Object> faker, int minLen, int maxLen, boolean duplicated) {

-        Preconditions.checkArgument(!faker.isUnionFaker());

+        Preconditions.checkArgument(!faker.isUnionFaker() && !faker.isComputeFaker());

         this.faker = faker;

         this.minLen = Math.max(minLen, 0);

         this.maxLen = maxLen;

diff --git a/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/EvalFaker.java b/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/EvalFaker.java
new file mode 100644
index 0000000..e37d7e7
--- /dev/null
+++ b/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/EvalFaker.java
@@ -0,0 +1,34 @@
+package com.geedgenetworks.connectors.mock.faker;

+

+import com.googlecode.aviator.AviatorEvaluator;

+import com.googlecode.aviator.Expression;

+

+import java.util.Map;

+

+public class EvalFaker extends Faker<Object> {

+    private final String expression;

+    private Expression script;

+

+    public EvalFaker(String expression) {

+        this.expression = expression;

+    }

+

+    @Override

+    public void init(int instanceCount, int instanceIndex) throws Exception {

+        script = AviatorEvaluator.compile(expression, true);

+    }

+

+    @Override

+    public Object geneValue() throws Exception {

+        throw new UnsupportedOperationException();

+    }

+

+    public Object geneValue(Map<String, Object> params) throws Exception {

+        return script.execute(params);

+    }

+

+    @Override

+    public boolean isComputeFaker() {

+        return true;

+    }

+}

diff --git a/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/Faker.java b/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/Faker.java
index dc80585..44a80e1 100644
--- a/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/Faker.java
+++ b/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/Faker.java
@@ -11,4 +11,8 @@ public abstract class Faker<T> implements Serializable {
     public boolean isUnionFaker(){

         return false;

     }

+

+    public boolean isComputeFaker(){

+        return false;

+    }

 }

diff --git a/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/FakerUtils.java b/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/FakerUtils.java
index 9465b09..09cc8f8 100644
--- a/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/FakerUtils.java
+++ b/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/FakerUtils.java
@@ -50,6 +50,8 @@ public class FakerUtils {
             return wrapFaker(parseObjectFaker(obj.getJSONArray("fields")), obj);

         } else if ("Union".equalsIgnoreCase(type)) {

             return wrapFaker(parseUnionFaker(obj), obj);

+        } else if ("Eval".equalsIgnoreCase(type)) {

+            return parseEvalFaker(obj);

         }

 

         throw new UnsupportedOperationException("not support type:" + type);

@@ -95,6 +97,12 @@ public class FakerUtils {
         return new UnionFaker(fieldsFakers, random);

     }

 

+    private static Faker<?> parseEvalFaker(JSONObject obj) {

+        String expression = obj.getString("expression");

+        Preconditions.checkNotNull(expression);

+        return new EvalFaker(expression);

+    }

+

     private static Faker<?> parseExpressionFaker(JSONObject obj) {

         String expression = obj.getString("expression");

         Preconditions.checkNotNull(expression);

diff --git a/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/ObjectFaker.java b/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/ObjectFaker.java
index 7842ff5..5b77323 100644
--- a/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/ObjectFaker.java
+++ b/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/ObjectFaker.java
@@ -1,16 +1,18 @@
 package com.geedgenetworks.connectors.mock.faker;

 

 import java.io.Serializable;

+import java.util.Arrays;

 import java.util.LinkedHashMap;

-import java.util.List;

 import java.util.Map;

 

 public class ObjectFaker extends Faker<Map<String, Object>> {

     private final FieldFaker[] fields;

+    private final ComputeFieldFaker[] computeFields;

     private final int initialCapacity;

 

     public ObjectFaker(FieldFaker[] fields) {

-        this.fields = fields;

+        this.fields = Arrays.stream(fields).filter(x -> !x.faker.isComputeFaker()).toArray(FieldFaker[]::new);

+        this.computeFields = Arrays.stream(fields).filter(x -> x.faker.isComputeFaker()).map(x -> new ComputeFieldFaker(x.name, (EvalFaker)x.faker)).toArray(ComputeFieldFaker[]::new);

         this.initialCapacity = (int) (fields.length / 0.75);

     }

 

@@ -19,14 +21,20 @@ public class ObjectFaker extends Faker<Map<String, Object>> {
         for (FieldFaker field : fields) {

             field.faker.init(instanceCount, instanceIndex);

         }

+        for (ComputeFieldFaker computeField : computeFields) {

+            computeField.faker.init(instanceCount, instanceIndex);

+        }

     }

 

     @Override

     public Map<String, Object> geneValue() throws Exception {

         Map<String, Object> map = new LinkedHashMap<>(initialCapacity);

         FieldFaker fieldFaker;

+        ComputeFieldFaker computeFieldFaker;

+        UnionFaker.FieldValuesAndComputeFieldFakers fieldValuesAndComputeFieldFakers;

         Object value;

-        for (int i = 0; i < fields.length; i++) {

+        int len = fields.length;

+        for (int i = 0; i < len; i++) {

             fieldFaker = fields[i];

             value = fieldFaker.faker.geneValue();

             if(value == null){

@@ -35,10 +43,31 @@ public class ObjectFaker extends Faker<Map<String, Object>> {
             if (!fieldFaker.faker.isUnionFaker()) {

                 map.put(fieldFaker.name, value);

             } else {

-                for (UnionFaker.FieldValue fieldValue : (List<UnionFaker.FieldValue>) value) {

+                fieldValuesAndComputeFieldFakers = (UnionFaker.FieldValuesAndComputeFieldFakers) value;

+                for (UnionFaker.FieldValue fieldValue : fieldValuesAndComputeFieldFakers.fieldValues) {

                     map.put(fieldValue.name, fieldValue.value);

                 }

+

+                len = fieldValuesAndComputeFieldFakers.computeFields.length;

+                for (int j = 0; j < len; j++) {

+                    computeFieldFaker = fieldValuesAndComputeFieldFakers.computeFields[j];

+                    value = computeFieldFaker.faker.geneValue(map);

+                    if(value == null){

+                        continue;

+                    }

+                    map.put(computeFieldFaker.name, value);

+                }

+            }

+        }

+

+        len = computeFields.length;

+        for (int i = 0; i < len; i++) {

+            computeFieldFaker = computeFields[i];

+            value = computeFieldFaker.faker.geneValue(map);

+            if(value == null){

+                continue;

             }

+            map.put(computeFieldFaker.name, value);

         }

         return map;

     }

@@ -48,6 +77,9 @@ public class ObjectFaker extends Faker<Map<String, Object>> {
         for (FieldFaker field : fields) {

             field.faker.destroy();

         }

+        for (ComputeFieldFaker computeField : computeFields) {

+            computeField.faker.destroy();

+        }

     }

 

     public static final class FieldFaker implements Serializable {

@@ -59,4 +91,14 @@ public class ObjectFaker extends Faker<Map<String, Object>> {
             this.faker = faker;

         }

     }

+

+    public static final class ComputeFieldFaker implements Serializable {

+        public final String name;

+        public final EvalFaker faker;

+

+        public ComputeFieldFaker(String name, EvalFaker faker) {

+            this.name = name;

+            this.faker = faker;

+        }

+    }

 }

diff --git a/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/UnionFaker.java b/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/UnionFaker.java
index 2d4426f..956e4ed 100644
--- a/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/UnionFaker.java
+++ b/groot-connectors/connector-mock/src/main/java/com/geedgenetworks/connectors/mock/faker/UnionFaker.java
@@ -6,11 +6,12 @@ import java.util.Arrays;
 import java.util.List;

 import java.util.Random;

 

-public class UnionFaker extends Faker<List<UnionFaker.FieldValue>> {

+public class UnionFaker extends Faker<UnionFaker.FieldValuesAndComputeFieldFakers> {

     private final FieldsFaker[] fieldsFakers;

     private final boolean random;

     private final FieldValue[] fieldValuesTmp;

     private final List<FieldValue> fieldValues;

+    private final FieldValuesAndComputeFieldFakers fieldValuesAndComputeFieldFakers;

     private final int[] weights;

     private final int weightMax;

     private Random r;

@@ -21,6 +22,7 @@ public class UnionFaker extends Faker<List<UnionFaker.FieldValue>> {
         this.random = random;

         this.fieldValuesTmp = new FieldValue[Arrays.stream(fieldsFakers).mapToInt(x -> x.fields.length).max().getAsInt()];

         this.fieldValues = new ArrayList<>();

+        this.fieldValuesAndComputeFieldFakers = new FieldValuesAndComputeFieldFakers();

         this.weights = new int[fieldsFakers.length];

         weights[0] = fieldsFakers[0].weight;

         for (int i = 1; i < fieldsFakers.length; i++) {

@@ -39,11 +41,14 @@ public class UnionFaker extends Faker<List<UnionFaker.FieldValue>> {
             for (ObjectFaker.FieldFaker field : fieldsFaker.fields) {

                 field.faker.init(instanceCount, instanceIndex);

             }

+            for (ObjectFaker.ComputeFieldFaker field : fieldsFaker.computeFields) {

+                field.faker.init(instanceCount, instanceIndex);

+            }

         }

     }

 

     @Override

-    public List<FieldValue> geneValue() throws Exception {

+    public FieldValuesAndComputeFieldFakers geneValue() throws Exception {

         fieldValues.clear();

 

         FieldsFaker fieldsFaker;

@@ -84,7 +89,10 @@ public class UnionFaker extends Faker<List<UnionFaker.FieldValue>> {
             }

         }

 

-        return fieldValues;

+        fieldValuesAndComputeFieldFakers.fieldValues = fieldValues;

+        fieldValuesAndComputeFieldFakers.computeFields = fieldsFaker.computeFields;

+

+        return fieldValuesAndComputeFieldFakers;

     }

 

     @Override

@@ -93,6 +101,9 @@ public class UnionFaker extends Faker<List<UnionFaker.FieldValue>> {
             for (ObjectFaker.FieldFaker field : fieldsFaker.fields) {

                 field.faker.destroy();

             }

+            for (ObjectFaker.ComputeFieldFaker field : fieldsFaker.computeFields) {

+                field.faker.destroy();

+            }

         }

     }

 

@@ -106,13 +117,21 @@ public class UnionFaker extends Faker<List<UnionFaker.FieldValue>> {
         public Object value;

     }

 

+    public static class FieldValuesAndComputeFieldFakers implements Serializable {

+        public List<FieldValue> fieldValues;

+        public ObjectFaker.ComputeFieldFaker[] computeFields;

+

+    }

+

     public static class FieldsFaker implements Serializable {

         final ObjectFaker.FieldFaker[] fields;

+        final ObjectFaker.ComputeFieldFaker[] computeFields;

         final int weight;

         int weightIndex = 0;

 

         public FieldsFaker(ObjectFaker.FieldFaker[] fields, int weight) {

-            this.fields = fields;

+            this.fields = Arrays.stream(fields).filter(x -> !x.faker.isComputeFaker()).toArray(ObjectFaker.FieldFaker[]::new);

+            this.computeFields = Arrays.stream(fields).filter(x -> x.faker.isComputeFaker()).map(x -> new ObjectFaker.ComputeFieldFaker(x.name, (EvalFaker)x.faker)).toArray(ObjectFaker.ComputeFieldFaker[]::new);

             this.weight = weight;

         }

     }