自定義Mybatis自動生成程式碼規則
阿新 • • 發佈：2020-07-11
前言
大家都清楚mybatis-generate-core 這個工程提供了獲取表資訊到生成model、dao、xml這三層程式碼的一個實現，但是這往往有一個痛點，比如需求來了，某個表需要增加欄位，肯定需要重新執行mybatis自動生成的指令碼，但是會去覆蓋之前的程式碼，如model,dao的java程式碼，對於xml檔案，目前有兩種處理方式，一、覆蓋，二、追加，本文用的版本是1.3.5版本，預設的是追加方式，本文的目的就是處理xml的一種合併方式，對於java程式碼的話，我個人認為無論是增加表字段還是其他情況，相對於xml檔案都是比較好維護的，這裡就不做討論。
對於方式一的話，直接覆蓋，肯定會導致之前自定義的sql，直接沒了，還需要事先拷貝一份出來，最蛋疼的就是，可能還會在自動生成的程式碼檔案中，增加了一些屬性(如主鍵返回，flushCache屬性)，導致後來人員給忽略了，直到某個時刻才爆發出來。所以本文不採用這種方式，而是採用方式2，對於mybatis自定義的合併規則，看下文介紹。本文會對這個合併規則，進行重寫，已達到我們的目標。如下
- 在啟用自動生成程式碼後，原有的自定義sql，一律保留，包括,result|sql|select|delete|update|where|insert等標籤，只要不是自動生成的
- 自動生成的標籤中，手動新增的一些屬性，如主鍵返回useGeneratedKeys="true" keyColumn="id"，重新整理一級快取,flushCache="true"等屬性標籤也需要保留。
在重寫該規則前，肯定是要摸清它的原有流程，下面分為這幾個小節進行敘述
一、合併規則原理
二、重寫規則
三、簡述適用場景
本文采用的資料庫是Mysql
一、合併規則原理
先來一段程式碼，莫慌，這段程式碼沒什麼特別，很常見的自動生成程式碼
1 package com.qm.mybatis.generate;
2
3 import org.mybatis.generator.api.MyBatisGenerator;
4 import org.mybatis.generator.config.Configuration;
5 import org.mybatis.generator.config.xml.ConfigurationParser;
6 import org.mybatis.generator.internal.DefaultShellCallback;
7
8 import java.io.InputStream;
9 import java.util.ArrayList;
10 import java.util.List;
11
12 public class GenerateTest {
13
14 public static void main(String[] args) {
15 List<String> warnings = new ArrayList<String>();
16 try {
17 boolean overwrite = true;
18 // 讀取配置檔案
19 InputStream resourceAsStream = GenerateTest.class.getResourceAsStream("/mybatis-generate.xml");
20 ConfigurationParser cp = new ConfigurationParser(warnings);
21 Configuration config = cp.parseConfiguration(resourceAsStream);
22 DefaultShellCallback callback = new DefaultShellCallback(overwrite);
23 MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
24 myBatisGenerator.generate(null);
25 } catch (Exception e) {
26
27 e.printStackTrace();
28 }
29
30 warnings.stream().forEach(warn -> {
31 System.out.println(warn);
32 });
33 System.out.println("生成成功！");
34 }
35 }
可見，最終的生成邏輯在MybatisGenerator#generate方法中，
1 // 最終生成程式碼的地方
2 public void generate(ProgressCallback callback, Set<String> contextIds,
3 Set<String> fullyQualifiedTableNames, boolean writeFiles) throws SQLException,
4 IOException, InterruptedException {
5
6 if (callback == null) {
7 callback = new NullProgressCallback();
8 }
9
10 generatedJavaFiles.clear();
11 generatedXmlFiles.clear();
12 ObjectFactory.reset();
13 RootClassInfo.reset();
14
15 // calculate the contexts to run
16 List<Context> contextsToRun;
17 if (contextIds == null || contextIds.size() == 0) {
18 contextsToRun = configuration.getContexts();
19 } else {
20 contextsToRun = new ArrayList<Context>();
21 for (Context context : configuration.getContexts()) {
22 if (contextIds.contains(context.getId())) {
23 contextsToRun.add(context);
24 }
25 }
26 }
27
28 // setup custom classloader if required
29 if (configuration.getClassPathEntries().size() > 0) {
30 ClassLoader classLoader = getCustomClassloader(configuration.getClassPathEntries());
31 ObjectFactory.addExternalClassLoader(classLoader);
32 }
33
34 // now run the introspections...
35 int totalSteps = 0;
36 for (Context context : contextsToRun) {
37 totalSteps += context.getIntrospectionSteps();
38 }
39 callback.introspectionStarted(totalSteps);
40
41 for (Context context : contextsToRun) {
42 context.introspectTables(callback, warnings,
43 fullyQualifiedTableNames);
44 }
45
46 // now run the generates
47 totalSteps = 0;
48 for (Context context : contextsToRun) {
49 totalSteps += context.getGenerationSteps();
50 }
51 callback.generationStarted(totalSteps);
52
53 for (Context context : contextsToRun) {
54 context.generateFiles(callback, generatedJavaFiles,
55 generatedXmlFiles, warnings);
56 }
57
58 // 前面各種檔案都已經生成完畢，在這裡進行儲存到具體的檔案中
59 if (writeFiles) {
60 callback.saveStarted(generatedXmlFiles.size()
61 + generatedJavaFiles.size());
62
63 // 進行xml檔案儲存(更新)的地方，也是本文的目標
64 for (GeneratedXmlFile gxf : generatedXmlFiles) {
65 projects.add(gxf.getTargetProject());
66 writeGeneratedXmlFile(gxf, callback);
67 }
68
69 // 儲存java檔案，如model,example,dao
70 for (GeneratedJavaFile gjf : generatedJavaFiles) {
71 projects.add(gjf.getTargetProject());
72 writeGeneratedJavaFile(gjf, callback);
73 }
74
75 for (String project : projects) {
76 shellCallback.refreshProject(project);
77 }
78 }
79
80 callback.done();
81 }
最終的落實地方就在writeGeneratedXmlFile方法內。
1 private void writeGeneratedXmlFile(GeneratedXmlFile gxf, ProgressCallback callback)
2 throws InterruptedException, IOException {
3 File targetFile;
4 String source;
5 try {
6 File directory = shellCallback.getDirectory(gxf
7 .getTargetProject(), gxf.getTargetPackage());
8 targetFile = new File(directory, gxf.getFileName());
9 // 如果為false，基本上就是第一次生成的時候
10 if (targetFile.exists()) {
11
12 /**
13 * 從這裡也可以看出，這個引數決定xml檔案的處理方式
14 * 為true時，會執行getMergedSource，透個底，改造也是改造這個方法
15 false，會繼續後面兩種邏輯。實際生成的內容其實是一樣的。這裡不做討論
16 */
17 if (gxf.isMergeable()) {
18 source = XmlFileMergerJaxp.getMergedSource(gxf,
19 targetFile);
20 } else if (shellCallback.isOverwriteEnabled()) {
21 source = gxf.getFormattedContent();
22 warnings.add(getString("Warning.11", //$NON-NLS-1$
23 targetFile.getAbsolutePath()));
24 } else {
25 source = gxf.getFormattedContent();
26 targetFile = getUniqueFileName(directory, gxf
27 .getFileName());
28 warnings.add(getString(
29 "Warning.2", targetFile.getAbsolutePath())); //$NON-NLS-1$
30 }
31 } else {
32 source = gxf.getFormattedContent();
33 }
34
35 callback.checkCancel();
36 callback.startTask(getString(
37 "Progress.15", targetFile.getName())); //$NON-NLS-1$
38 writeFile(targetFile, source, "UTF-8"); //$NON-NLS-1$
39 } catch (ShellException e) {
40 warnings.add(e.getMessage());
41 }
42 }
饒了這麼多圈，實際上我們要處理的就是重寫XmlFileMergerJaxp#getMergedSource方法，或許有的人會提出疑問了，這個類能讓你提供擴充套件嗎？讓你去繼承？然後去改變這個規則，額(⊙o⊙)…，還真沒有，這個類實際上就是一個靜態方法，那這搞個毛線啊，你即使重寫出來了，那你怎麼將他插入進去，別告訴你準備重新編譯原始碼。。。。。莫慌，往下看。
說到這，大家可以去了解一下類載入器和其載入的過程，本文不做過多闡述，直接來結論，你要想覆蓋一個jar包裡的某個方法，你就直接在你專案中，定義這個類(包名和類名需要完全一致)，然後執行的時候，自然會執行你定義的這個類，千萬別去想著同樣的方法去覆蓋jdk自帶的類，沒用，因為第三方jar包和jdk自帶的類的類載入器不是同一個。有興趣的可以去網上搜索一下。說了這麼多，我們就是要這樣做。做之前，先了解下這個merge方法的程式碼。
1 public static String getMergedSource(InputSource newFile,
2 InputSource existingFile, String existingFileName) throws IOException, SAXException,
3 ParserConfigurationException, ShellException {
4
5 DocumentBuilderFactory factory = DocumentBuilderFactory
6 .newInstance();
7 factory.setExpandEntityReferences(false);
8 DocumentBuilder builder = factory.newDocumentBuilder();
9 builder.setEntityResolver(new NullEntityResolver());
10
11 // 這是xml檔案的解析結果，這裡就暫且稱為舊檔案和新檔案
12 Document existingDocument = builder.parse(existingFile);
13 Document newDocument = builder.parse(newFile);
14
15 DocumentType newDocType = newDocument.getDoctype();
16 DocumentType existingDocType = existingDocument.getDoctype();
17
18 // 比較兩個xml檔案是不是同一型別
19 if (!newDocType.getName().equals(existingDocType.getName())) {
20 throw new ShellException(getString("Warning.12", //$NON-NLS-1$
21 existingFileName));
22 }
23
24 // 獲取根節點
25 Element existingRootElement = existingDocument.getDocumentElement();
26 Element newRootElement = newDocument.getDocumentElement();
27
28
29 NamedNodeMap attributes = existingRootElement.getAttributes();
30 int attributeCount = attributes.getLength();
31 for (int i = attributeCount - 1; i >= 0; i--) {
32 Node node = attributes.item(i);
33 existingRootElement.removeAttribute(node.getNodeName());
34 }
35
36 // add attributes from the new root node to the old root node
37 attributes = newRootElement.getAttributes();
38 attributeCount = attributes.getLength();
39 for (int i = 0; i < attributeCount; i++) {
40 Node node = attributes.item(i);
41 existingRootElement.setAttribute(node.getNodeName(), node
42 .getNodeValue());
43 }
44
45 // remove the old generated elements and any
46 // white space before the old nodes
47 List<Node> nodesToDelete = new ArrayList<Node>();
48 NodeList children = existingRootElement.getChildNodes();
49 int length = children.getLength();
50 for (int i = 0; i < length; i++) {
51 Node node = children.item(i);
52 if (isGeneratedNode(node)) {
53 nodesToDelete.add(node);
54 } else if (isWhiteSpace(node)
55 && isGeneratedNode(children.item(i + 1))) {
56 nodesToDelete.add(node);
57 }
58 }
59
60 for (Node node : nodesToDelete) {
61 existingRootElement.removeChild(node);
62 }
63
64 // add the new generated elements
65 children = newRootElement.getChildNodes();
66 length = children.getLength();
67 Node firstChild = existingRootElement.getFirstChild();
68 for (int i = 0; i < length; i++) {
69 Node node = children.item(i);
70 // don't add the last node if it is only white space
71 if (i == length - 1 && isWhiteSpace(node)) {
72 break;
73 }
74
75 Node newNode = existingDocument.importNode(node, true);
76 if (firstChild == null) {
77 existingRootElement.appendChild(newNode);
78 } else {
79 existingRootElement.insertBefore(newNode, firstChild);
80 }
81 }
82
83 // pretty print the result
84 return prettyPrint(existingDocument);
85 }
啟動的29~43行，的目的是替換mapper節點的namespace，方式重新生成後，namespace有改變
之後的47~62行，就是刪除一些節點，其實按照他這意思就是為了刪掉特定的節點，具體實現邏輯在isGeneratedNode方法內，由它決定刪不刪。
65~81行就是將新檔案中的所有節點(非空白節點)全部合併至舊檔案中。
1 private static boolean isGeneratedNode(Node node) {
2 boolean rc = false;
3
4 if (node != null && node.getNodeType() == Node.ELEMENT_NODE) {
5 Element element = (Element) node;
6 String id = element.getAttribute("id"); //$NON-NLS-1$
7 if (id != null) {
8 for (String prefix : MergeConstants.OLD_XML_ELEMENT_PREFIXES) {
9 if (id.startsWith(prefix)) {
10 rc = true;
11 break;
12 }
13 }
14 }
15
16 if (rc == false) {
17 // check for new node format - if the first non-whitespace node
18 // is an XML comment, and the comment includes
19 // one of the old element tags,
20 // then it is a generated node
21 NodeList children = node.getChildNodes();
22 int length = children.getLength();
23 for (int i = 0; i < length; i++) {
24 Node childNode = children.item(i);
25 if (isWhiteSpace(childNode)) {
26 continue;
27 } else if (childNode.getNodeType() == Node.COMMENT_NODE) {
28 Comment comment = (Comment) childNode;
29 String commentData = comment.getData();
30 for (String tag : MergeConstants.OLD_ELEMENT_TAGS) {
31 if (commentData.contains(tag)) {
32 rc = true;
33 break;
34 }
35 }
36 } else {
37 break;
38 }
39 }
40 }
41 }
42
43 return rc;
44 }
邏輯其實也很簡單，4~14行的邏輯就是刪除id屬性值帶有一些特定字首的節點，如果沒找到，這刪除commentNode節點，看到這，結果就出來了，按照正常情況下，根本不會把之前的就節點給刪除掉。還是完完全全的保留。至此，就是我們常說的追加。
二、重寫規則
從上述內容中，熟悉了原有的程式碼合併規則，接下來就是自定義規則了，本文就不放程式碼了，那樣感覺很囉嗦，就直接簡述一下實現思路，具體程式碼會在文末貼出github連結，可自行檢視。
一、遍歷新檔案的所有非空白節點，遍歷同時獲取到對應舊檔案中的節點，這裡不考慮舊檔案中有刪除自動生成的節點情況，若獲取到了，則遍歷屬性，有無增加，若增加，則移植到新檔案中對應節點上，同時對該舊檔案中的節點進行標記，等遍歷完刪掉。
二、第一個步驟完成後，然後再將新檔案中的所有節點全部移植到舊檔案中，最後視情況，需不需要格式化一下xml檔案。
具體規則，就是圖中紅框處的檔案
具體效果，大家可自行嘗試，這裡不貼效果圖了。畢竟眼見為實。
注：不保證該規則適用於所有格式的xml檔案，這塊需要實地嘗試。
三、適用場景
本文這種方式，只適用於程式碼來生成檔案的方式，對於適用maven外掛，並不適用，如果需要，這裡提供一種無奈方案，就是獲取對應原始碼，替換掉該類，重新編譯成jar包，放入到本地倉庫裡。
程式碼地址：Mybatis-generate-demo
四、最後
如果還有其它比較好的方案。歡迎交流。
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
轉載請註明出處
&n