masterchengsheng
commented
4 years ago @Data
public class Rule implements Serializable {
@JSONField(serializeUsing = com.smartcall.common.dto.rule.serializable.RuleSerializable.class,
deserializeUsing = com.smartcall.common.dto.rule.serializable.RuleDeserializable.class)
private List<Stage> rules;
}@Data
@NoArgsConstructor
@AllArgsConstructor
public class Stage implements Serializable {
private String stageName;
private List<RuleNode> nodes;
}@Data
@NoArgsConstructor
@AllArgsConstructor
public class RuleNode implements Serializable {
private String nodeName;
private List<LogicRule> logicRuleList;
}
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LogicRule implements Serializable {
/**
* and or not 逻辑名称
*/
private String logicName;
/**
* 子规则
*/
private List<LogicRule> childrenRule;
/**
* 底层的规则
*/
private List<RuleItem> items;
}
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RuleItem implements Serializable {
/**
* in
*/
private String target;
/**
*
*/
private String desc;
/**
* input_text
* context
*/
private String category;
public List<String> assList() {
return Lists.newArrayList(this.target, this.desc, this.category);
}
public static RuleItem fillData(List<String> list) {
if (CollectionUtils.isEmpty(list)) {
return null;
}
if (list.size() != 3) {
return null;
}
RuleItem item = new RuleItem();
item.target = list.get(0);
item.desc = list.get(1);
item.category = list.get(2);
return item;
}
}
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.DefaultJSONParser;
import com.alibaba.fastjson.parser.deserializer.ObjectDeserializer;
import com.google.common.collect.Lists;
import com.smartcall.common.dto.rule.LogicRule;
import com.smartcall.common.dto.rule.RuleItem;
import com.smartcall.common.dto.rule.RuleNode;
import com.smartcall.common.dto.rule.Stage;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
public class RuleDeserializable implements ObjectDeserializer {
@Override
public List<Stage> deserialze(DefaultJSONParser defaultJSONParser, Type type, Object fieldName) {
String input = defaultJSONParser.getInput();
List<Stage> stages = new ArrayList<>();
JSONObject jsonObject = JSONObject.parseObject(input);
Set<String> set = jsonObject.keySet();
if (set.contains("rules")) {
Object rules = jsonObject.get("rules");
if (Objects.isNull(rules)) {
return Lists.newArrayList();
}
JSONObject rulesObj = (JSONObject) rules;
Set<String> strings = rulesObj.keySet();
for (String string : strings) {
Object o = rulesObj.get(string);
Stage stage = new Stage();
stages.add(stage);
stage.setStageName(string);
if (Objects.isNull(o)) {
continue;
}
analysisHandler(stage, o);
}
} else {
return Lists.newArrayList();
}
return stages;
}
public static final List<String> logicTarget = Lists.newArrayList("and", "or", "not");
private void analysisHandler(Stage stage, Object obj) {
JSONObject jsonObject = (JSONObject) obj;
for (String key : jsonObject.keySet()) {
JSONArray array = jsonObject.getJSONArray(key);
analysisRuleNode(array, stage, key);
}
}
private void analysisRuleNode(JSONArray array, Stage stage, String key) {
RuleNode ruleNode = new RuleNode();
if (stage.getNodes() == null) {
stage.setNodes(Lists.newArrayList(ruleNode));
} else {
stage.getNodes().add(ruleNode);
}
ruleNode.setNodeName(key);
List<Object> list = array.toJavaList(Object.class);
List<RuleItem> ruleItems = Lists.newArrayList();
List<LogicRule> logicRules = Lists.newArrayList();
LogicRule logicRule = new LogicRule();
ruleNode.setLogicRuleList(Lists.newArrayList(logicRule));
logicRule.setItems(ruleItems);
logicRule.setChildrenRule(logicRules);
for (Object o : list) {
if (o instanceof String) {
logicRule.setLogicName(o.toString());
} else {
List<String> list1 = (List<String>) o;
String s = list1.get(0);
if (logicTarget.contains(s)) {
LogicRule lr = analysisLogicRule((JSONArray) o);
if (Objects.nonNull(lr)) {
logicRules.add(lr);
}
} else {
RuleItem item = RuleItem.fillData(list1);
if (Objects.isNull(item)) {
continue;
}
ruleItems.add(item);
}
}
}
}
private LogicRule analysisLogicRule(JSONArray array) {
LogicRule logicRule = new LogicRule();
List<RuleItem> ruleItems = Lists.newArrayList();
List<LogicRule> logicRules = Lists.newArrayList();
logicRule.setItems(ruleItems);
logicRule.setChildrenRule(logicRules);
List<Object> list = array.toJavaList(Object.class);
for (Object o : list) {
if (o instanceof String) {
logicRule.setLogicName(o.toString());
} else {
List<String> list1 = (List<String>) o;
String s = list1.get(0);
if (logicTarget.contains(s)) {
LogicRule lr = analysisLogicRule((JSONArray) o);
if (Objects.nonNull(lr)) {
logicRules.add(lr);
}
} else {
RuleItem item = RuleItem.fillData(list1);
if (Objects.isNull(item)) {
continue;
}
ruleItems.add(item);
}
}
}
return logicRule;
}
@Override
public int getFastMatchToken() {
return 0;
}
}
import com.alibaba.fastjson.serializer.JSONSerializer;
import com.alibaba.fastjson.serializer.ObjectSerializer;
import com.google.common.collect.Lists;
import com.smartcall.common.dto.rule.LogicRule;
import com.smartcall.common.dto.rule.RuleItem;
import com.smartcall.common.dto.rule.RuleNode;
import com.smartcall.common.dto.rule.Stage;
import org.apache.commons.collections.CollectionUtils;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
public class RuleSerializable implements ObjectSerializer {
@Override
public void write(JSONSerializer jsonSerializer, Object o, Object fieldName, Type type, int i) throws IOException {
List<Stage> stages = (List<Stage>) o;
Map<String, Map<String, List<Object>>> map = new LinkedHashMap<>();
for (Stage stage : stages) {
String stageName = stage.getStageName();
List<RuleNode> nodes = stage.getNodes();
Map<String, List<Object>> innerMap = new LinkedHashMap();
if (CollectionUtils.isEmpty(nodes)) {
map.put(stageName, innerMap);
continue;
}
for (RuleNode node : nodes) {
String nodeName = node.getNodeName();
List<LogicRule> logicRuleList = node.getLogicRuleList();
if (CollectionUtils.isEmpty(logicRuleList)) {
innerMap.put(nodeName, Lists.newArrayList());
continue;
}
List<Object> list = new ArrayList<>();
for (LogicRule logicRule : logicRuleList) {
String logicName = logicRule.getLogicName();
List<RuleItem> items = logicRule.getItems();
List<LogicRule> children = logicRule.getChildrenRule();
list.add(logicName);
if (CollectionUtils.isNotEmpty(items)) {
for (RuleItem item : items) {
list.add(item.assList());
}
}
if (CollectionUtils.isNotEmpty(children)) {
recursionAnalysis(children, list);
}
}
innerMap.put(nodeName, list);
}
map.put(stageName, innerMap);
}
jsonSerializer.write(map);
}
private void recursionAnalysis(List<LogicRule> children, List<Object> list) {
if (CollectionUtils.isEmpty(children)) {
return;
}
for (LogicRule child : children) {
String logicName = child.getLogicName();
List<RuleItem> items = child.getItems();
List<LogicRule> childrenRuleList = child.getChildrenRule();
List<Object> subList = new ArrayList<>();
subList.add(logicName);
if (CollectionUtils.isNotEmpty(items)) {
for (RuleItem item : items) {
subList.add(item.assList());
}
}
if (CollectionUtils.isNotEmpty(childrenRuleList)) {
recursionAnalysis(childrenRuleList, subList);
}
list.add(subList);
}
}
}
ChunC-Wu
自定义序列号和反序列化操作 序列化时OK 反序列化时 报错