問題引入

Json是什么就不多說了，本文把Json理解成一種協(xié)議。

印象之中，Json貌似是前端的專屬，其實(shí)不然，服務(wù)器端組織數(shù)據(jù)，依然可以用Json協(xié)議。

比如說，某公司有一套測評題目（基于Json協(xié)議），這些題目比較珍貴，不想直接放在js中，所以就將題目文件放在服務(wù)器端，然后通過一個(gè)接口去請求，多一層控制，就多了一層保護(hù)，通過在接口上加權(quán)限，可保證數(shù)據(jù)安全。

如此一來，服務(wù)器端必定會有一個(gè)Json文件（純文本文件），Json文件中包含Json數(shù)據(jù)。

假設(shè)Json數(shù)據(jù)結(jié)構(gòu)如下：

 1 { 2   "name": "題庫", 3   "items": [{ 4     "name": "測評-1", 5     "items": [/*...*/] 6   },{ 7     "name": "測評-2", 8     "items": [/*...*/] 9   },{10     "name": "測評-3",11     "items": [/*...*/]12   }/*...*/]13 }

暫不討論這樣設(shè)計(jì)的合理性，假定已經(jīng)是這么設(shè)計(jì)了，無法再做更改。但凡是有些規(guī)模的項(xiàng)目，需求變動都比較頻繁，項(xiàng)目工期也比較緊張，不得不做出妥協(xié)，完美的設(shè)計(jì)是不存在的。

隨著時(shí)間和規(guī)模的增長，測評會越來越多，而且每個(gè)測評本身包含的數(shù)據(jù)也不少，這樣一來，這個(gè)Json文件會越來越大。

眾所周知，IO操作是一個(gè)巨大的瓶頸，如果Json文件太大，占用IO過多，將導(dǎo)致性能嚴(yán)重下降。同時(shí)Json文件太大，也不好管理，不符合開閉原則。

因此，我們迫切需要對Json文件進(jìn)行拆分，把數(shù)據(jù)量大、獨(dú)立性強(qiáng)、自成一體的Json數(shù)據(jù)轉(zhuǎn)移到主體的外部，單獨(dú)放在一個(gè)Json文件中，這樣不僅縮小了單個(gè)文件的體積，也方便管理。

其實(shí)這樣做最大的優(yōu)點(diǎn)是可以實(shí)現(xiàn)懶加載，或者說是按需加載。

這樣的情景很常見，比如在進(jìn)行數(shù)據(jù)檢索時(shí)，一般情況下，會先看到一個(gè)數(shù)據(jù)概要列表，列出幾項(xiàng)重要信息，其他次要信息需要點(diǎn)擊“詳情”按鈕時(shí)，才去加載。

拿上邊測評的例子來說，第一步僅需顯示出有哪些測評，然后根據(jù)用戶的選擇，再去加載對應(yīng)測評的詳細(xì)信息。沒有必要一上來就把所有的信息都返回給客戶端，不僅浪費(fèi)資源，還降低了數(shù)據(jù)安全性。

如何才能實(shí)現(xiàn)Json文件的合并呢？請看下章~~~

解決方案：Jean

Jean是一個(gè)java工具類，她可以實(shí)現(xiàn)Json文件合并、依賴管理，靈感來自于前端模塊化開發(fā)。

這名字是怎么來的呢？前端模塊化開發(fā)，國內(nèi)比較厲害的就是Sea.js了，小菜要寫的是Java工具類，要不就叫Jea？于是趕緊上網(wǎng)查查Jea有沒有啥特殊含義，萬一是敏感詞就不好了。結(jié)果一查，查到了Jean，可翻譯為“珍”，相當(dāng)不錯的名字嘛，就是她了！

Jean的思想是在Json文件中，加入一段特殊代碼，來引入其他Json文件，有點(diǎn)像jsp中的include。語法為：@Jean("family","./items/family.js")。可以把@Jean()理解成函數(shù)調(diào)用，里邊有兩個(gè)參數(shù)，第一個(gè)參數(shù)是屬性名稱，第二個(gè)參數(shù)是依賴文件的相對路徑。

文章開篇測評的例子，可以寫成這樣：

 1 { 2   "name": "題庫", 3   "items": [{ 4     "name": "測評-1", 5     @Jean("items","./items1/test.js") 6   },{ 7     "name": "測評-2", 8     @Jean("items","./items2/test.js") 9   },{10     @Jean("items","./items3/test.js"),11     "name": "測評-3"12   }/*...*/]13 }

假設(shè)./items1/test.js中內(nèi)容為：

1 {2   name: "測評-1-內(nèi)容"3 }

由此可以看出，@Jean在Json文件中的寫法，就和普通的屬性寫法一樣，如果是寫在最后邊，末尾就不用加逗號，其他情況同樣需要加逗號。

通過工具類解析之后，@Jean("items","./items1/test.js")會變成："items": {name: "測評-1-內(nèi)容"}，替換之后，為了保證格式正確，所以寫@Jean的時(shí)候需要按照正常的語法加逗號。

第一個(gè)參數(shù)，將會轉(zhuǎn)換成@Jean占位符被替換后的Json屬性名稱，如果不寫，默認(rèn)為"jean"。

第二個(gè)參數(shù)是該屬性依賴的Json文件的相對路徑，當(dāng)然是相對于當(dāng)前Json文件的，Jean會根據(jù)當(dāng)前Json文件的路徑，找到依賴的Json文件，然后讀取內(nèi)容，再合并到當(dāng)前Json文件中。目前小菜實(shí)現(xiàn)的Jean工具類，只能識別./和../兩種相對路徑語法（含義與HTML相對路徑語法相同）。

所以，@Jean僅僅是一個(gè)占位符，包含有@Jean的Json字符串，必須經(jīng)過Jean工具類處理之后，才是合法的Json字符串。同時(shí)，Jean僅僅關(guān)心依賴，而不關(guān)心依賴的組織形式，這樣可以帶來巨大的靈活性，無論怎樣組織文件結(jié)構(gòu)，最終體現(xiàn)到Jean的僅僅是一個(gè)相對路徑而已。

Jean工具類提供了三個(gè)public方法：

 1 /** 2  * 解析所有的jean表達(dá)式 3  * @param json json字符串 4  * @param jsonPath json字符串所在路徑，完整路徑 5  * @return 解析后的json字符串 6  */ 7 public static String parseAll(String json,String jsonPath){} 8  9 /**10  * 解析單個(gè)jean表達(dá)式11  * @param exPRess jean表達(dá)式12  * @param jsonPath json字符串所在路徑，完整路徑13  * @return 解析結(jié)果14  */15 public static String parSEOne(String express,String jsonPath){}16 17 /**18  * 解析特定的jean表達(dá)式19  * @param json json字符串20  * @param jsonPath json字符串所在路徑，完整路徑21  * @param names 需要解析的屬性名稱列表22  * @return 解析后的json字符串23  */24 public static String parseTarget(String json,String jsonPath,List<String> names){}

第一個(gè)方法就是說給我一個(gè)包含@Jean的Json字符串，再給我這個(gè)Json字符串所在文件的絕對路徑，我就把所有的@Jean解析成依賴文件中的內(nèi)容。

為啥非要單獨(dú)傳入一個(gè)絕對路徑呢？其實(shí)可以直接傳入Json文件的路徑，這樣既能拿到需要解析的Json字符串，又能獲取當(dāng)前Json文件的絕對路徑。但這樣有一個(gè)缺點(diǎn)，就是每調(diào)用一次，就要讀一次文件，小菜單獨(dú)把路徑寫成一個(gè)參數(shù)，就是要把讀文件的過程留給用戶，具體怎么讀，由用戶說了算，最終把需要解析的Json字符串和參照路徑給我就可以了。例如：

1 String json = "{@Jean(/"item1/",/"./../../item.js/"),@Jean(/"item2/",/"../item.js/")}";2 System.out.println(parseAll(json, "E:/root/json")); //print {"item1": {"name": "xxx1"},"item2": {"name": "xxx2"}}

第二個(gè)方法可以直接解析一個(gè)@Jean表達(dá)式，不多解釋。例如：

1 String expression = "@Jean(/"item1/",/"./../../item.js/")";2 System.out.println(parseOne(expression, "E:/root/json")); //print "item1": {"name": "xxx1"}

第三個(gè)方法可以解析指定的@Jean表達(dá)式，@Jean表達(dá)式第一個(gè)參數(shù)是屬性名稱，想解析哪個(gè)屬性，就把它放在List<String>中，其他不做解析的，屬性值為null。這樣就實(shí)現(xiàn)了懶加載。例如：

1 List<String>  names = new ArrayList<String>();2 names.add("item1");3 String json = "{@Jean(/"item1/",/"./../../item.js/"),@Jean(/"item2/",/"../item.js/")}";4 System.out.println(parseTarget(json, "E:/root/json", names)); //print {"item1": {"name": "xxx"},"item2": null}

Jean源碼

  1 import java.io.BufferedReader;  2 import java.io.File;  3 import java.io.FileInputStream;  4 import java.io.IOException;  5 import java.io.InputStreamReader;  6 import java.util.ArrayList;  7 import java.util.HashMap;  8 import java.util.List;  9 import java.util.Map; 10 import java.util.regex.Matcher; 11 import java.util.regex.Pattern; 12  13  14 /** 15  * json文件合并工具類 16  * @author 楊元 17  */ 18 public class Jean { 19      20     /** 21      * 識別jean表達(dá)式 22      */ 23     private static Pattern jeanRegex = Pattern.compile("(@Jean//((/"[^/"]*/",)?/"[^/"]*/"http://))"); 24     /** 25      * 識別jean表達(dá)式中的所有參數(shù) 26      */ 27     private static Pattern paramRegex = Pattern.compile("/"([^/"]*)/""); 28     /** 29      * 識別jean表達(dá)式中的name參數(shù) 30      */ 31     private static Pattern nameRegex = Pattern.compile("/"([^/"]*)/","); 32     /** 33      * 默認(rèn)屬性名稱 34      */ 35     private static String defaultName = "jean"; 36      37     /** 38      * 解析所有的jean表達(dá)式 39      * @param json json字符串 40      * @param jsonPath json字符串所在路徑，完整路徑 41      * @return 解析后的json字符串 42      */ 43     public static String parseAll(String json,String jsonPath){ 44         //識別jean表達(dá)式 45         List<String> jeans = regexMatchList(jeanRegex, json); 46         jeans = noRepeat(jeans); 47          48         //解析 49         for(String jean : jeans){ 50             json = json.replace(jean, parse(jean, jsonPath)); 51         } 52          53         return json; 54     } 55      56     /** 57      * 解析單個(gè)jean表達(dá)式 58      * @param express jean表達(dá)式 59      * @param jsonPath json字符串所在路徑，完整路徑 60      * @return 解析結(jié)果 61      */ 62     public static String parseOne(String express,String jsonPath){ 63         return parse(express, jsonPath); 64     } 65      66     /** 67      * 解析特定的jean表達(dá)式 68      * @param json json字符串 69      * @param jsonPath json字符串所在路徑，完整路徑 70      * @param names 需要解析的屬性名稱列表 71      * @return 解析后的json字符串 72      */ 73     public static String parseTarget(String json,String jsonPath,List<String> names){ 74         //識別jean表達(dá)式 75         List<String> jeans = regexMatchList(jeanRegex, json); 76         jeans = noRepeat(jeans); 77         //處理屬性名映射 78         Map<String, Boolean> nameMap = new HashMap<String, Boolean>(); 79         for(String s : names){ 80             nameMap.put(s, true); 81         } 82          83         //解析 84         String replacement = ""; 85         Matcher matcher = null; 86         String name = ""; 87         for(String jean : jeans){ 88             matcher = nameRegex.matcher(jean); 89              90             //判斷是否傳入屬性名稱 91             if(matcher.find()){ 92                 name = matcher.group(1); 93                 //判斷是否需要解析 94                 if(nameMap.get(name) != null){ 95                     replacement = parse(jean, jsonPath); 96                 }else{ 97                     //不需要解析直接將屬性值寫為null 98                     replacement = "/""+name+"/": null"; 99                 }100             }else{101                 //無屬性名直接用默認(rèn)的jean102                 replacement = "/""+defaultName+"/": null";103             }104             105             json = json.replace(jean, replacement);106         }107         108         return json;109     }110     111     /**112      * 解析jean表達(dá)式113      * @param express jean表達(dá)式114      * @param jsonPath json文件所在路徑，完整路徑115      * @return jean表達(dá)式執(zhí)行結(jié)果116      */117     private static String parse(String express,String jsonPath){118         //識別參數(shù)119         List<String> params = regexMatchList(paramRegex, express);120         //默認(rèn)屬性名稱121         String name = defaultName;122         //格式化路徑123         jsonPath = removeSuffix(jsonPath, "/");124         125         //判斷是否傳入了屬性名稱126         if(params.size() > 1){127             name = params.get(0);128         }129         130         //解析路徑131         String path = getAbsolutePath(jsonPath, params.get(params.size()-1));132         133         //讀取內(nèi)容并返回134         name = wrapWith(name, "/"");135         return name + ": " + readJsonFile(path);136     }137     138     /**139      * 從字符串中移除指定后綴140      * @param source 源字符串141      * @param suffix 需要移除的后綴142      * @return 處理后的源字符串143      */144     private static String removeSuffix(String source,String suffix){145         if(source.endsWith(suffix)){146             source = source.substring(0, source.length()-suffix.length());147         }148         149         return source;150     }151     152     /**153      * list內(nèi)容去重154      * @param list 內(nèi)容為string的list155      * @return 內(nèi)容去重后的list156      */157     private static List<String> noRepeat(List<String> list){158         Map<String, String> map = new HashMap<String, String>();159         List<String> result = new ArrayList<String>();160         161         for(String s : list){162             map.put(s, null);163         }164         165         for(String s : map.keySet()){166             result.add(s);167         }168         169         return result;170     }171     172     /**173      * 用指定的字符串包裹內(nèi)容174      * @param content 內(nèi)容175      * @param wrap 包裹字符串176      * @return 包裹后的內(nèi)容177      */178     private static String wrapWith(String content,String wrap){179         return wrap+content+wrap;180     }181     182     /**183      * 讀取Json文件(純文本文件，utf-8編碼)184      * 這個(gè)方法可以替換成自己項(xiàng)目中封裝的方法185      * @param path 文件路徑186      * @return 文件內(nèi)容187      */188     private static String readJsonFile(String path){189         String encoding = "utf-8";190         StringBuilder sb = new StringBuilder(256);191         192         File file = new File(path);193         InputStreamReader iReader = null;194         BufferedReader bReader = null;195         196         try{197             iReader = new InputStreamReader(new FileInputStream(file), encoding);198             bReader = new BufferedReader(iReader);199             String line = null;200             201             while((line = bReader.readLine()) != null){202                 sb.append(line.trim());203             }204             205             bReader.close();206             iReader.close();207             208         }catch(Exception e){209             if(iReader != null){210                 try {211                     iReader.close();212                 } catch (IOException e1) {213                     iReader = null;214                 }215             }216             if(bReader != null){217                 try {218                     bReader.close();219                 } catch (IOException e1) {220                     bReader = null;221                 }222             }223         }224         225         return sb.toString();226     }227     228     /**229      * 將相對路徑轉(zhuǎn)換成絕對路徑230      * 只識別 ./ ../231      * @param refrence 基準(zhǔn)參照路徑232      * @param relative 相對路徑表達(dá)式233      * @return 絕對路徑234      */235     private static String getAbsolutePath(String refrence,String relative){236         if(relative.startsWith("./")){237             refrence = getAbsolutePath(refrence, relative.replaceFirst("http://./", ""));238         }else if(relative.startsWith("../")){239             refrence = getAbsolutePath(refrence.substring(0, refrence.lastIndexOf("/")), 240                             relative.replaceFirst("http://.//./", ""));241         }else{242             refrence = refrence + "/" + relative;243         }244         245         return refrence;246     }247     248     /**249      * 將正則表達(dá)式的匹配結(jié)果轉(zhuǎn)換成列表250      * @param regex 正則表達(dá)式對象251      * @param input 要檢索的字符串252      * @return 結(jié)果列表253      */254     private static List<String> regexMatchList(Pattern regex,String input){255         List<String> result = new ArrayList<String>();256         Matcher matcher = regex.matcher(input);257         while(matcher.find()){258             result.add(matcher.group(1));259         }260         261         return result;262     }263 264 265 }

其他

歡迎留言，共同探討！