20240712 邀请会员

src/main/java/com/example/xiaoshiweixinback/business/utils/parseQueryToTree/ExpressTreeNode.java

@@ -0,0 +1,447 @@
+package com.example.xiaoshiweixinback.business.utils.parseQueryToTree;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+public class ExpressTreeNode {
+
+
+    public static treeNode Tokens2Node(List<String> Tokens, boolean isAnd)throws Exception
+
+    {
+
+        Stack<Symbol> symbolStack = new Stack<Symbol>();
+
+        Stack<treeNode> valueStack = new Stack<treeNode>();
+
+
+
+        boolean preIsValue = false;
+
+        for (int i = 0; i < Tokens.size(); i++)
+
+        {
+
+            String strTem = Tokens.get(i);
+
+
+
+            Symbol temSymbol = expressManager.getInstance().getSymbol(strTem);
+
+
+
+            if (temSymbol != null)
+
+            {
+
+                if (temSymbol instanceof operate)
+
+                {
+//                        region 如果是操作符，从操作符堆栈中取出优先级大于等于该操作符的结合值堆栈生成节点后压入值堆栈，然后将该操作符压入堆栈
+
+                    operate temoperate = (operate)temSymbol;
+
+
+
+                    if (symbolStack.size() > 0)
+
+                    {
+
+                        Symbol lastSymbol = symbolStack.peek();
+
+
+
+                        while (lastSymbol instanceof operate && ((operate)lastSymbol).priorityVale >= temoperate.priorityVale)
+
+                        {
+
+                            operateNode temSymbolNode = new operateNode();
+
+                            temSymbolNode.operate = (operate)lastSymbol;
+
+
+
+                            if (((operate)lastSymbol).operateValue == 1)
+
+                            {
+
+                                temSymbolNode.Right = valueStack.pop();
+
+                            }
+
+                            else
+
+                            {
+
+                                temSymbolNode.Right = valueStack.pop();
+
+                                temSymbolNode.Left = valueStack.pop();
+
+                            }
+
+
+
+                            valueStack.push(temSymbolNode);
+
+
+
+                            symbolStack.pop();
+
+
+
+                            if (symbolStack.size() > 0)
+
+                            {
+
+                                lastSymbol = symbolStack.peek();
+
+                            }
+
+                            else
+
+                            {
+
+                                break;
+
+                            }
+
+                        }
+
+                    }
+
+
+
+
+
+                    symbolStack.push(temSymbol);
+                    preIsValue = false;
+                }
+                    else
+
+                {
+
+                    if (temSymbol instanceof pairSymbol && ((pairSymbol)temSymbol).isEndSymbol == false)
+
+                    {
+
+                        List<String> strings = new ArrayList<>();
+
+
+
+                        int zkh = 1;
+
+                        for(int j = i+1; j < Tokens.size(); j++)
+
+                        {
+
+                            String s = Tokens.get(j);
+
+
+
+                            Symbol sysTem = expressManager.getInstance().getSymbol(s);
+
+
+
+                            if(sysTem != null)
+
+                            {
+
+                                if (sysTem instanceof pairSymbol)
+
+                                {
+
+                                    if (((pairSymbol)sysTem).isEndSymbol)
+
+                                    {
+
+                                        zkh--;
+
+                                    }
+
+                                    else
+
+                                    {
+
+                                        zkh++;
+
+                                    }
+
+                                }
+
+
+
+                            }
+
+
+
+                            if(zkh == 0)
+
+                            {
+
+                                break ;
+
+                            }
+
+                            else
+
+                            {
+
+                                strings.add(s);
+
+                            }
+
+
+
+                        }
+
+
+
+                        if(zkh == 0)
+
+                        {
+
+                            valueStack.push(Tokens2Node(strings, isAnd));
+
+                            preIsValue = true;
+
+                            i = i + strings.size() +1;
+
+                        }
+
+                    }
+
+                }
+
+            }
+
+            else
+
+            {
+
+                if(preIsValue && symbolStack.size() > 0)
+
+                {
+
+                    if (symbolStack.size() > 0)
+
+                    {
+
+                        Symbol lastSymbol = symbolStack.pop();
+
+
+
+                        operateNode temSymbolNode = new operateNode();
+
+                        temSymbolNode.operate =(operate) lastSymbol;
+
+
+
+                        if (((operate)lastSymbol).operateValue == 1)
+
+                        {
+
+                            temSymbolNode.Right = valueStack.pop();
+
+                        }
+
+                        else
+
+                        {
+
+                            temSymbolNode.Right = valueStack.pop();
+
+                            temSymbolNode.Left = valueStack.pop();
+
+                        }
+
+                        valueStack.push(temSymbolNode);
+
+
+
+                    }
+
+
+
+                }
+
+
+
+                valueNode  temNode = new valueNode();
+
+                temNode.value = strTem;
+
+                valueStack.push(temNode);
+
+                preIsValue = true;
+
+            }
+
+
+
+        }
+
+
+
+        while (symbolStack.size() > 0)
+
+        {
+
+            Symbol temSymbol = symbolStack.pop();
+
+
+
+            if (temSymbol instanceof operate)
+
+            {
+
+                operateNode temNode = new operateNode();
+
+                temNode.operate = (operate)temSymbol;
+
+
+
+                if (((operate)temSymbol).operateValue == 1)
+
+                {
+
+                    temNode.Right = valueStack.pop();
+
+                }
+
+                else
+
+                {
+
+                    temNode.Right = valueStack.pop();
+
+                    temNode.Left = valueStack.pop();
+
+                }
+
+
+
+                valueStack.push(temNode);
+
+
+
+            }
+
+                else
+
+            {
+
+                throw new Exception("无效的括号！");
+
+            }
+
+        }
+
+
+
+
+
+        if (valueStack.size() ==1)
+
+        {
+
+            return valueStack.pop();
+
+
+
+        }
+
+        else
+
+        {
+
+            if (valueStack.size() > 1)
+
+            {
+
+                List<treeNode> lstValues = new ArrayList<>();
+
+
+
+                while (valueStack.size() > 0)
+
+                {
+
+                    treeNode temNode = valueStack.pop();
+
+
+
+                    lstValues.add(0, temNode);
+
+                }
+
+
+
+                treeNode retNode = null;
+
+
+
+                for (treeNode temNode :lstValues)
+                {
+
+                    if (retNode == null)
+
+                    {
+
+                        retNode = temNode;
+
+                    }
+
+                    else
+
+                    {
+
+                        operateNode sNode = new operateNode();
+
+
+
+                        if (!isAnd)
+
+                        {
+
+                            sNode.operate = (operate) expressManager.getInstance().getSymbol("OR");
+
+                        }
+
+                        else
+
+                        {
+
+                            sNode.operate = (operate)expressManager.getInstance().getSymbol("AND");
+
+                        }
+
+
+
+                        sNode.Left = retNode;
+
+                        sNode.Right = temNode;
+
+                        retNode = sNode;
+
+                    }
+
+                }
+
+
+
+                return retNode;
+
+            }
+
+
+
+            throw new Exception("无效的检索式！");
+
+        }
+
+
+
+    }
+
+}

src/main/java/com/example/xiaoshiweixinback/business/utils/parseQueryToTree/expressManager.java

@@ -1,5 +1,9 @@
 package com.example.xiaoshiweixinback.business.utils.parseQueryToTree;
 
+
+
+import com.example.xiaoshiweixinback.business.utils.StringUtils;
+
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -32,8 +36,8 @@ public class expressManager {
         oOR.Code = "NOT";
         oOR.ShowName = "NOT";
         oOR.type = enuType.Logic;
-        oOR.priorityVale = 11;
-        oOR.operateValue = 2;
+        oOR.priorityVale = 12;
+        oOR.operateValue = 1;
         hSymbols.put(oOR.Code, oOR);
 
         oOR = new operate();
@@ -44,13 +48,6 @@ public class expressManager {
         oOR.operateValue = 2;
         hSymbols.put(oOR.Code, oOR);
 
-        oOR = new operate();
-        oOR.Code = "~";
-        oOR.ShowName = "TO";
-        oOR.type = enuType.Logic;
-        oOR.priorityVale = 21;
-        oOR.operateValue = 2;
-        hSymbols.put(oOR.Code, oOR);
 
         oOR = new operate();
         oOR.Code = "=";
@@ -148,21 +145,8 @@ public class expressManager {
 
     public Symbol getSymbol(String strSymbol) {
         String strKey = strSymbol.trim().toUpperCase();
-        if ((strKey != null && !strKey.trim().equals(""))) {
-            if (hSymbols.containsKey(strKey)) {
-                return hSymbols.get(strKey);
-            } else if (strKey.matches("\\$W[0-9]+")) {
-                operate tem = new operate();
-                tem = new operate();
-                tem.Code = strKey;
-                tem.ShowName = strKey;
-                tem.type = enuType.Assignment;
-                tem.priorityVale = 24;
-                tem.operateValue = 2;
-                return tem;
-            } else {
-                return null;
-            }
+        if ((strKey != null && !strKey.trim().equals("")) && hSymbols.containsKey(strKey)) {
+            return hSymbols.get(strKey);
         } else {
             return null;
         }
@@ -178,147 +162,167 @@ public class expressManager {
         ArrayList<String> Tokens = GetTokens(strExpress);
         Stack<Symbol> symbolStack = new Stack<Symbol>();
         Stack<treeNode> valueStack = new Stack<treeNode>();
-        for (String strTem : Tokens) {
-            Symbol temSymbol = expressManager.getInstance().getSymbol(strTem);
-            if (temSymbol != null) {
-                if (temSymbol instanceof operate) {
-                    //#region 如果是操作符，从操作符堆栈中取出优先级大于等于该操作符的结合值堆栈生成节点后压入值堆栈，然后将该操作符压入堆栈
-                    operate temOperate = (operate) temSymbol;
-                    if (symbolStack.size() > 0) {
-                        Symbol lastSymbol = symbolStack.peek();
-
-                        while (lastSymbol instanceof operate && ((operate) lastSymbol).priorityVale >= temOperate.priorityVale) {
-                            operateNode temSymbolNode = new operateNode();
-                            temSymbolNode.operate = (operate) lastSymbol;
-                            if (((operate) lastSymbol).operateValue == 1) {
-                                temSymbolNode.Right = valueStack.pop();
-                            } else {
-                                temSymbolNode.Right = valueStack.pop();
-                                temSymbolNode.Left = valueStack.pop();
-                            }
-
-                            valueStack.push(temSymbolNode);
-
-                            symbolStack.pop();
-
-                            if (symbolStack.size() > 0) {
-                                lastSymbol = symbolStack.peek();
-                            } else {
-                                break;
-                            }
-                        }
-                    }
-                    symbolStack.push(temSymbol);
-                    //#endregion
-                } else {
-                    //#region 括号处理
-                    if (temSymbol instanceof pairSymbol && ((pairSymbol) temSymbol).isEndSymbol) {
-                        Symbol lastSymbol = symbolStack.peek();
-
-                        if (lastSymbol == null) {
-                            throw new Exception("无效的括号！");
-                        }
-
-                        while (lastSymbol instanceof operate ||
-                                (lastSymbol instanceof pairSymbol && ((pairSymbol) lastSymbol).Code != ((pairSymbol) temSymbol).previewSymbol.Code)) {
-                            operateNode temSymbolNode = new operateNode();
-                            temSymbolNode.operate = (operate) lastSymbol;
-
-                            if (((operate) lastSymbol).operateValue == 1) {
-                                temSymbolNode.Right = valueStack.pop();
-                            } else {
-                                temSymbolNode.Right = valueStack.pop();
-                                temSymbolNode.Left = valueStack.pop();
-                            }
-                            valueStack.push(temSymbolNode);
-
-                            symbolStack.pop();
-                            lastSymbol = symbolStack.peek();
-                        }
-
-                        if ((lastSymbol instanceof pairSymbol && ((pairSymbol) temSymbol).previewSymbol.Code == ((pairSymbol) lastSymbol).Code)) {
-                            symbolStack.pop();
-                        } else {
-                            throw new Exception("无效的括号");
-                        }
-
-                    } else {
-                        symbolStack.push(temSymbol);
-                    }
-                    //#endregion
-                }
-            } else {
-                valueNode temNode = new valueNode();
-                temNode.value = strTem;
-
-                valueStack.push(temNode);
-            }
-        }
-
-        while (symbolStack.size() > 0) {
-            Symbol temSymbol = symbolStack.pop();
-
-            if (temSymbol instanceof operate) {
-                operateNode temNode = new operateNode();
-                temNode.operate = (operate) temSymbol;
-
-                if (((operate) temSymbol).operateValue == 1) {
-                    temNode.Right = valueStack.pop();
-                } else {
-                    temNode.Right = valueStack.pop();
-                    temNode.Left = valueStack.pop();
-                }
-
-                valueStack.push(temNode);
-
-            } else {
-                throw new Exception("无效的括号！");
-            }
-        }
-
-        if (valueStack.size() == 1) {
-            return valueStack.pop();
-        } else {
-
-            if (valueStack.size() > 1) {
-                List<treeNode> lstValues = new ArrayList<treeNode>();
-
-                while (valueStack.size() > 0) {
-                    treeNode temNode = valueStack.pop();
-
-                    if (temNode instanceof valueNode) {
-                        lstValues.add(temNode);
-                    } else {
-                        throw new Exception("无效的检索式！");
-                    }
-                }
-
-                treeNode retNode = null;
-
-                for (treeNode temNode : lstValues) {
-                    if (retNode == null) {
-                        retNode = temNode;
-                    } else {
-                        operateNode sNode = new operateNode();
-
-                        if (!isAnd) {
-                            sNode.operate = (operate) expressManager.getInstance().getSymbol("OR");
-                        } else {
-                            sNode.operate = (operate) expressManager.getInstance().getSymbol("AND");
-                        }
-
-                        sNode.Left = retNode;
-                        sNode.Right = temNode;
-                        retNode = sNode;
-                    }
-                }
-
-                return retNode;
-            }
-
-            throw new Exception("无效的检索式！");
-
-        }
+        List<String> middleKuoHaoStrs = new ArrayList<>();
+            return ExpressTreeNode.Tokens2Node(Tokens, isAnd);
+//        Boolean ifFindEndingMiddleKuoHaoStrs = false;
+//        for (String strTem : Tokens) {
+//            Symbol temSymbol = expressManager.getInstance().getSymbol(strTem);
+//            if (ifFindEndingMiddleKuoHaoStrs && (temSymbol == null || !(temSymbol instanceof pairSymbol && ((pairSymbol) temSymbol).Code.equals("]")))) {
+//                middleKuoHaoStrs.add(strTem);
+//            } else if (temSymbol != null) {
+//                if (temSymbol instanceof operate) {
+//                    //#region 如果是操作符，从操作符堆栈中取出优先级大于等于该操作符的结合值堆栈生成节点后压入值堆栈，然后将该操作符压入堆栈
+//                    operate temOperate = (operate) temSymbol;
+//                    if (symbolStack.size() > 0) {
+//                        Symbol lastSymbol = symbolStack.peek();
+//
+//                        while (lastSymbol instanceof operate && ((operate) lastSymbol).priorityVale >= temOperate.priorityVale) {
+//                            operateNode temSymbolNode = new operateNode();
+//                            temSymbolNode.operate = (operate) lastSymbol;
+//                            if (((operate) lastSymbol).operateValue == 1) {
+//                                temSymbolNode.Right = valueStack.pop();
+//                            } else {
+//                                temSymbolNode.Right = valueStack.pop();
+//                                temSymbolNode.Left = valueStack.pop();
+//                            }
+//
+//                            valueStack.push(temSymbolNode);
+//
+//                            symbolStack.pop();
+//
+//                            if (symbolStack.size() > 0) {
+//                                lastSymbol = symbolStack.peek();
+//                            } else {
+//                                break;
+//                            }
+//                        }
+//                    }
+//                    symbolStack.push(temSymbol);
+//                    //#endregion
+//                } else {
+//                    if (temSymbol instanceof pairSymbol && ((pairSymbol) temSymbol).Code.equals("[")) {
+//                        ifFindEndingMiddleKuoHaoStrs = true;
+//                    } else if (temSymbol instanceof pairSymbol && ((pairSymbol) temSymbol).Code.equals("]")) {
+//                        ifFindEndingMiddleKuoHaoStrs = false;
+//                        String temp = StringUtils.join(middleKuoHaoStrs, ",");
+//                        valueNode temNode = new valueNode();
+//                        temNode.value = temp;
+//                        valueStack.push(temNode);
+//                        middleKuoHaoStrs = new ArrayList<>();
+//                    }
+//
+//                    //#region 括号处理
+//                    else if (temSymbol instanceof pairSymbol && ((pairSymbol) temSymbol).isEndSymbol) {
+//                        Symbol lastSymbol = symbolStack.peek();
+//
+//                        if (lastSymbol == null) {
+//                            throw new Exception("无效的括号！");
+//                        }
+//
+//                        while (lastSymbol instanceof operate ||
+//                                (lastSymbol instanceof pairSymbol && ((pairSymbol) lastSymbol).Code != ((pairSymbol) temSymbol).previewSymbol.Code)) {
+//                            operateNode temSymbolNode = new operateNode();
+//                            temSymbolNode.operate = (operate) lastSymbol;
+//
+//                            if (((operate) lastSymbol).operateValue == 1) {
+//                                temSymbolNode.Right = valueStack.pop();
+//                            } else {
+//                                temSymbolNode.Right = valueStack.pop();
+//                                temSymbolNode.Left = valueStack.pop();
+//                            }
+//                            valueStack.push(temSymbolNode);
+//
+//                            symbolStack.pop();
+//                            lastSymbol = symbolStack.peek();
+//                        }
+//
+//                        if ((lastSymbol instanceof pairSymbol && ((pairSymbol) temSymbol).previewSymbol.Code == ((pairSymbol) lastSymbol).Code)) {
+//                            symbolStack.pop();
+//                        } else {
+//                            throw new Exception("无效的括号");
+//                        }
+//
+//                    } else {
+//                        symbolStack.push(temSymbol);
+//                    }
+//                    //#endregion
+//                }
+//            } else {
+//                if (!ifFindEndingMiddleKuoHaoStrs) {
+//                    valueNode temNode = new valueNode();
+//                    temNode.value = strTem;
+//
+//                    valueStack.push(temNode);
+//                } else {
+//                    middleKuoHaoStrs.add(strTem);
+//                }
+//            }
+//        }
+//
+//        while (symbolStack.size() > 0) {
+//            Symbol temSymbol = symbolStack.pop();
+//
+//            if (temSymbol instanceof operate) {
+//                operateNode temNode = new operateNode();
+//                temNode.operate = (operate) temSymbol;
+//
+//                if (((operate) temSymbol).operateValue == 1) {
+//                    temNode.Right = valueStack.pop();
+//                } else {
+//                    temNode.Right = valueStack.pop();
+//                    temNode.Left = valueStack.pop();
+//                }
+//
+//                valueStack.push(temNode);
+//
+//            } else {
+//                throw new Exception("无效的括号！");
+//            }
+//        }
+//
+//        if (valueStack.size() == 1) {
+//            return valueStack.pop();
+//        } else {
+//
+//            if (valueStack.size() > 1) {
+//                List<treeNode> lstValues = new ArrayList<treeNode>();
+//
+//                while (valueStack.size() > 0) {
+//                    treeNode temNode = valueStack.pop();
+//
+//                    if (temNode instanceof valueNode) {
+//                        lstValues.add(temNode);
+//                    } else {
+//                        throw new Exception("无效的检索式！");
+//                    }
+//                }
+//
+//                treeNode retNode = null;
+//
+//                for (treeNode temNode : lstValues) {
+//                    if (retNode == null) {
+//                        retNode = temNode;
+//                    } else {
+//                        operateNode sNode = new operateNode();
+//
+//                        if (!isAnd) {
+//                            sNode.operate = (operate) expressManager.getInstance().getSymbol("OR");
+//                        } else {
+//                            sNode.operate = (operate) expressManager.getInstance().getSymbol("AND");
+//                        }
+//
+//                        sNode.Left = retNode;
+//                        sNode.Right = temNode;
+//                        retNode = sNode;
+//                    }
+//                }
+//
+//                return retNode;
+//            }
+//
+//            throw new Exception("无效的检索式！");
+//
+//        }
     }
 
 
@@ -336,11 +340,14 @@ public class expressManager {
 
             String strTemToken = "";
             Boolean isFindingEndYinHao = false;
+            Boolean ifFindingEndMiddleKuoHao = false;
             int step = -1;
             for (int i = 0; i < strTem.length(); i++) {
                 char c = strTem.charAt(i);
 
                 switch (c) {
+                    case '“':
+                    case '”':
                     case '"':
                         if (!isFindingEndYinHao) {
                             isFindingEndYinHao = true;
@@ -357,6 +364,7 @@ public class expressManager {
                             }
 
                         }
+
                         break;
                     case ' ':
                         if (!isFindingEndYinHao) {
@@ -372,33 +380,46 @@ public class expressManager {
                         break;
                     case '(':
                     case '[':
-                        if (i == 0 || strTem.charAt(i - 1) == ' ' || (Tokens.size() > 0 && Tokens.get(Tokens.size() - 1) == String.valueOf(c)) || strTem.charAt(i - 1) == '=') {
-                            Tokens.add(String.valueOf(c));
-                            step = i;
+                        if (!isFindingEndYinHao) {
+                            if (step == (i - 1)) {
+                                Tokens.add(String.valueOf(c));
+                                step = i;
+                            } else {
+                                if (i == 0 || strTem.charAt(i - 1) == ' ' || (Tokens.size() > 0 && Tokens.get(Tokens.size() - 1) == String.valueOf(c)) || strTem.charAt(i - 1) == '=') {
+                                    Tokens.add(String.valueOf(c));
+                                    step = i;
+                                }
+                            }
                         }
                         break;
                     case ')':
                     case ']':
-                        if ((i < strTem.length() - 1 && (strTem.charAt(i + 1) == ' ' || strTem.charAt(i + 1) == c)) || i == strTem.length() - 1) {
-                            Boolean isAdd = false;
-                            for (int index = Tokens.size() - 1; index >= 0; index--) {
-                                if ((c == ')' && Tokens.get(index).equals("(")) || (c == ']' && Tokens.get(index).equals("["))) {
-                                    isAdd = true;
-                                    break;
-                                }
-                            }
-                            if (isAdd) {
-                                strTemToken = strTem.substring(step + 1, i);
-                                if (strTemToken != null && !strTemToken.equals("")) {
-                                    Tokens.add(strTemToken);
-                                }
+                        if (!isFindingEndYinHao) {
+                            if (step == (i - 1)) {
                                 Tokens.add(String.valueOf(c));
                                 step = i;
+                            } else {
+                                if ((i < strTem.length() - 1 && (strTem.charAt(i + 1) == ' ' || strTem.charAt(i + 1) == c)) || i == strTem.length() - 1) {
+                                    Boolean isAdd = false;
+                                    for (int index = Tokens.size() - 1; index >= 0; index--) {
+                                        if ((c == ')' && Tokens.get(index).equals("(")) || (c == ']' && Tokens.get(index).equals("["))) {
+                                            isAdd = true;
+                                            break;
+                                        }
+                                    }
+                                    if (isAdd) {
+                                        strTemToken = strTem.substring(step + 1, i);
+                                        if (strTemToken != null && !strTemToken.equals("")) {
+                                            Tokens.add(strTemToken);
+                                        }
+                                        Tokens.add(String.valueOf(c));
+                                        step = i;
+                                    }
+                                }
                             }
                         }
                         break;
                     case '=':
-                    case '~':
                     case '>':
                     case '＞':
                     case '<':
@@ -430,4 +451,5 @@ public class expressManager {
             return null;
         }
     }
+
 }

src/main/resources/application-dev.yml

@@ -84,8 +84,8 @@ WeChat:
 Keypath: C:\Users\admin\Desktop\小程序证书\1673179188_20240408_cert\apiclient_key.pem
 queueName: emailProd.queue
 ES:
-  patentVector: patent_vector
-  patent: wxpatent
+  patentVector: cn_patent_vector_v5
+  patent: cn_weixin_patent_v4
   config: 192.168.2.24
 activity:
   jar-path: