Oracle 使用GSON库解析复杂json串

在前文中讲到了如何使用JSON标准库解析json串，参考：

Oracle解析复杂json的方法(转)

现补充一篇使用GSON库在Oracle中解析复杂json的方法。

GSON串的使用教程参考官方文档及

Gson使用一（Gson）

Gson使用二（GsonBuilder）

Gson使用三(集合的处理,一对多处理)

Gson使用四（TypeAdapter）

这一系列教程挺不错的，不过都使用了JavaBean，个人没有在Oracle里面直接使用JavaBean，GSON库提供了丰富的JsonElement处理方法。

1.执行loadjava命令导入处理json所需jar文件

loadjava -r   -f  -u  user/pwd@xxx.xxx.xxx.xxx:port/SID gson-2.8.2.jar

2.在数据库SQL窗口执行以下脚本,创建java源码对象

create or replace and compile java source named "Cux_Gson_Util" as


import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonElement;
import com.google.gson.JsonNull;
import com.google.gson.JsonParseException;
import com.google.gson.JsonParser;
import com.google.gson.JsonPrimitive;
import java.lang.Integer;

public class Cux_Gson_Util {
  
 public static boolean isJsonString(String json) {

        try {
            new JsonParser().parse(json);
            return true;
        } catch (JsonParseException e) {
            return false;
        } catch (NullPointerException e) {
            return false;
        } catch (Exception e) {
            return false;
        }
    }

    // 取json串单个节点值
    //json取值，有两种常见的异常，KEY不存在，空指针异常，数组型json，数组长度越界异常
    //应该还是要按Exceptin处理，否则由于传参的数据错误的话，就发现不了，直接当空值返回了。
    //不能返回空，应该在第一步数据校验里面直接抛出来。
    public static String getValue(String jsonStr, String nodeName) {
        String nodeValue = "";
            if (!isJsonString(jsonStr)) {
                nodeValue = "";
            } else {
                try{
                JsonParser jsonParser = new JsonParser();
                JsonObject obj = new JsonObject();
                obj = (JsonObject) jsonParser.parse(jsonStr);
                nodeValue = "";
                if (obj.get(nodeName) instanceof JsonObject) {
                    nodeValue = obj.get(nodeName).toString();
                } else if (obj.get(nodeName) instanceof JsonArray) {
                    nodeValue = obj.get(nodeName).toString();
                } else if (obj.get(nodeName) instanceof JsonPrimitive) {
                    // Error toString will , the result will start and end with "
                    // nodeValue = obj.get(nodeName).toString();

                    // 四种写法都可以
                    // nodeValue = obj.get(nodeName).getAsString();
                    // nodeValue = obj.getAsString();
                    // nodeValue =
                    // obj.get(nodeName).getAsJsonPrimitive().toString();
                    nodeValue = obj.get(nodeName).getAsJsonPrimitive().getAsString();
                } else if (obj.get(nodeName) instanceof JsonNull) {
                    nodeValue = "";
                } else{
                    nodeValue = obj.get(nodeName).getAsJsonPrimitive().getAsString();
                }
　　　　　　　　　 }catch(Exception e){
　　　　　　　　　　}


            }
        
        return nodeValue;
    }
    
    //取json数组长度便于循环处理
    public static int getArrayLength(String jsonArrayStr){
        int length=0;
        if(isJsonString(jsonArrayStr)){
            JsonArray jsonArr = new JsonParser().parse(jsonArrayStr).getAsJsonArray();
            length=jsonArr.size();
        }else{
            length = 0;
        }
        return length;
    }
    
    //取json数组第index个元素
    public static String getArrayValue(String jsonStr,Integer index){
         String nodeValue="";
            if(isJsonString(jsonStr)){
                JsonArray jsonArr = new JsonParser().parse(jsonStr).getAsJsonArray();
                //此处不能用getAsString()或者getAsJsonPrimitive()，因为数组中的类型未知，需要先做空判断
                if(jsonArr.get(index) instanceof JsonNull){
                    nodeValue = "";
                }else{
                    nodeValue = jsonArr.get(index).toString();
                }
            }else{
                nodeValue = null;
            }
         
         return nodeValue;
    }

    // 取json串下级节点值
    public static String getJsonValue(String jsonStr, String nodeName) {
        String nodeValue = "";

        if (isJsonString(jsonStr)) {
            JsonParser parser = new JsonParser();
            JsonElement jsonElement = parser.parse(jsonStr);

            if (jsonElement.isJsonNull()) {
                nodeValue = "";
            } else if (jsonElement.isJsonPrimitive()) {
                nodeValue = jsonElement.getAsJsonPrimitive().getAsString();
            } else if (jsonElement.isJsonObject()) {
                nodeValue = getJSONObjectValue(jsonElement.getAsJsonObject().toString(), nodeName);
            } else if (jsonElement.isJsonArray()) {
                nodeValue = getJSONArrayValue(jsonElement.getAsJsonArray().toString(), nodeName);
            } else {
                nodeValue = null;
            }

        }

        return nodeValue;

    }

    // 对于数组，以"@"作为分隔, index/nodeName形式，如 0@Amount
    public static String getJSONArrayValue(String jsonStr, String nodeName) {
        String nodeValue = "";
        JsonParser jsonParser = new JsonParser();
        JsonArray obj = jsonParser.parse(jsonStr).getAsJsonArray();

        int position = nodeName.indexOf("@");
        String objStr = nodeName.substring(0, position);
        int index = Integer.parseInt(objStr);
        String nodeStr = nodeName.substring(position + 1);
        //此处未做数组越界异常判断，
        
        nodeValue = getJsonValue(obj.get(index).toString(), nodeStr);
        return nodeValue;
    }

    // 参数nodeName，对于嵌套json以"/"作为分隔，比如HEADER/LINE
    public static String getJSONObjectValue(String jsonStr, String nodeName) {
        String nodeValue = null;
        JsonParser jsonParser = new JsonParser();
        JsonObject obj = jsonParser.parse(jsonStr).getAsJsonObject();

        int position = nodeName.indexOf("/");
        if (position == -1) {
            //此处未做Key是否存在的检查，如果要做，应该将检查方法单独提前校验
            if (obj.get(nodeName) instanceof JsonObject) {
                //此处可以直接用toString方法
                //nodeValue = obj.get(nodeName).toString();
                nodeValue = obj.get(nodeName).getAsJsonObject().getAsString();
            } else if (obj.get(nodeName) instanceof JsonArray) {
                //此处可以直接用toString方法
                //nodeValue = obj.get(nodeName).toString();
                nodeValue = obj.get(nodeName).getAsJsonArray().getAsString();
            } else if (obj.get(nodeName) instanceof JsonPrimitive) {
                nodeValue = obj.get(nodeName).getAsJsonPrimitive().getAsString();
            } else if (obj.get(nodeName) instanceof JsonNull) {
                nodeValue = "";
            } else {
                nodeValue = "";
            }
            
        } else {
            String objStr = nodeName.substring(0, position);
            String nodeStr = nodeName.substring(position + 1);
            nodeValue = getJsonValue(obj.get(objStr).toString(), nodeStr);
        }

        return nodeValue;

    }
}

3.利用步骤2创建的class创建function(或procedure),在此为了使其跟目前数据库已存在的json处理方法区分开，我们创建一个package，如下:

CREATE OR REPLACE PACKAGE Cux_Gson_Util_pkg AS
  --// 取json串单个KEY值
  FUNCTION getval(jsonstr VARCHAR2, nodename VARCHAR2) RETURN VARCHAR2;
  --//取json数组第index个元素
  FUNCTION getarrval(jsonarraystr VARCHAR2, index_num NUMBER) RETURN VARCHAR2;
  --//取json数组长度便于循环处理
  FUNCTION getarrlen(jsonarraystr VARCHAR2) RETURN NUMBER;

  --// 取json串下级节点值
  FUNCTION getjsonvalue(jsonarraystr VARCHAR2, nodename VARCHAR2)
    RETURN VARCHAR2;

  --// 对于数组，以"@"作为分隔, index/nodeName形式，如 0@Amount
  FUNCTION getjsonarrayvalue(jsonarraystr VARCHAR2, nodename VARCHAR2)
    RETURN VARCHAR2;

  --// 参数nodeName，对于嵌套json以"/"作为分隔，比如HEADER/LINE
  FUNCTION getjsonobjectvalue(jsonarraystr VARCHAR2, nodename VARCHAR2)
    RETURN VARCHAR2;

END Cux_Gson_Util_pkg;
/
CREATE OR REPLACE PACKAGE BODY Cux_Gson_Util_pkg AS
  FUNCTION getval(jsonstr VARCHAR2, nodename VARCHAR2) RETURN VARCHAR2 AS
    LANGUAGE JAVA NAME 'Cux_Gson_Util.getValue(java.lang.String,java.lang.String) return java.lang.String';

  FUNCTION getarrval(jsonarraystr VARCHAR2, index_num NUMBER) RETURN VARCHAR2 AS
    LANGUAGE JAVA NAME 'Cux_Gson_Util.getArrayValue(java.lang.String, java.lang.Integer) return java.lang.String';

  FUNCTION getarrlen(jsonarraystr VARCHAR2) RETURN NUMBER AS
    LANGUAGE JAVA NAME 'Cux_Gson_Util.getArrayLength(java.lang.String) return java.lang.Integer';

  FUNCTION getjsonvalue(jsonarraystr VARCHAR2, nodename VARCHAR2)
    RETURN VARCHAR2 AS
    LANGUAGE JAVA NAME 'Cux_Gson_Util.getJsonValue(java.lang.String,java.lang.String) return java.lang.String';

  FUNCTION getjsonarrayvalue(jsonarraystr VARCHAR2, nodename VARCHAR2)
    RETURN VARCHAR2 AS
    LANGUAGE JAVA NAME 'Cux_Gson_Util.getJSONArrayValue(java.lang.String,java.lang.String) return java.lang.String';

  FUNCTION getjsonobjectvalue(jsonarraystr VARCHAR2, nodename VARCHAR2)
    RETURN VARCHAR2 AS
    LANGUAGE JAVA NAME 'Cux_Gson_Util.getJSONObjectValue(java.lang.String,java.lang.String) return java.lang.String';

END Cux_Gson_Util_pkg;
/

4.

测试

SELECT cux_gson_util_pkg.getval('{"AA":"BB"}', 'AA') FROM DUAL;

结果
BB

SELECT cux_18_gson_util_pkg.getarrval('[{"AA":"BB"}]', 0) FROM DUAL;

结果

{"AA":"BB"}

SELECT cux_gson_util_pkg.getjsonvalue('[{"AA":"BB"}]', '0@AA') FROM DUAL;

结果

BB